├── .gitattributes
├── .gitignore
├── .vscode
    └── tasks.json
├── APIHelper
    ├── Get-APIHelperFunction.ps1
    ├── New-APIHelperFunction.ps1
    └── twitter_api.json
├── PSTwitterAPI.bootstrap.ps1
├── PSTwitterAPI.build.ps1
├── PSTwitterAPI
    ├── PSTwitterAPI.psd1
    ├── PSTwitterAPI.psm1
    ├── private
    │   ├── ConvertFrom-RateLimitStatus.ps1
    │   ├── Get-Eposh.ps1
    │   └── Get-OAuthParameters.ps1
    └── public
    │   ├── Get-TwitterApplication_RateLimitStatus.ps1
    │   ├── Get-TwitterOAuthSettings.ps1
    │   ├── Get-TwitterSearch_Tweets.ps1
    │   ├── Get-TwitterStatuses_HomeTimeline.ps1
    │   ├── Get-TwitterStatuses_MentionsTimeline.ps1
    │   ├── Get-TwitterStatuses_UserTimeline.ps1
    │   ├── Invoke-TwitterAPI.ps1
    │   ├── Send-TwitterDirectMessages_EventsNew.ps1
    │   ├── Set-TwitterOAuthSettings.ps1
    │   └── helper
    │       ├── Get-TwitterAccount_Settings.ps1
    │       ├── Get-TwitterAccount_VerifyCredentials.ps1
    │       ├── Get-TwitterBlocks_Ids.ps1
    │       ├── Get-TwitterBlocks_List.ps1
    │       ├── Get-TwitterCollections_Entries.ps1
    │       ├── Get-TwitterCollections_List.ps1
    │       ├── Get-TwitterCollections_Show.ps1
    │       ├── Get-TwitterCustomProfiles_List.ps1
    │       ├── Get-TwitterCustomProfiles__Id.ps1
    │       ├── Get-TwitterDirectMessages_EventsList.ps1
    │       ├── Get-TwitterDirectMessages_EventsShow.ps1
    │       ├── Get-TwitterDirectMessages_WelcomeMessagesList.ps1
    │       ├── Get-TwitterDirectMessages_WelcomeMessagesRulesList.ps1
    │       ├── Get-TwitterDirectMessages_WelcomeMessagesRulesShow.ps1
    │       ├── Get-TwitterDirectMessages_WelcomeMessagesShow.ps1
    │       ├── Get-TwitterFavorites_List.ps1
    │       ├── Get-TwitterFollowers_IDs.ps1
    │       ├── Get-TwitterFollowers_List.ps1
    │       ├── Get-TwitterFriends_IDs.ps1
    │       ├── Get-TwitterFriends_List.ps1
    │       ├── Get-TwitterFriendships_Incoming.ps1
    │       ├── Get-TwitterFriendships_Lookup.ps1
    │       ├── Get-TwitterFriendships_NoRetweetsIds.ps1
    │       ├── Get-TwitterFriendships_Outgoing.ps1
    │       ├── Get-TwitterFriendships_Show.ps1
    │       ├── Get-TwitterGeo_Id_PlaceId.ps1
    │       ├── Get-TwitterGeo_ReverseGeocode.ps1
    │       ├── Get-TwitterGeo_Search.ps1
    │       ├── Get-TwitterHelp_Configuration.ps1
    │       ├── Get-TwitterHelp_Languages.ps1
    │       ├── Get-TwitterHelp_Privacy.ps1
    │       ├── Get-TwitterHelp_Tos.ps1
    │       ├── Get-TwitterLists_Members.ps1
    │       ├── Get-TwitterLists_MembersShow.ps1
    │       ├── Get-TwitterLists_Memberships.ps1
    │       ├── Get-TwitterLists_Ownerships.ps1
    │       ├── Get-TwitterLists_Show.ps1
    │       ├── Get-TwitterLists_Statuses.ps1
    │       ├── Get-TwitterLists_Subscribers.ps1
    │       ├── Get-TwitterLists_SubscribersShow.ps1
    │       ├── Get-TwitterLists_Subscriptions.ps1
    │       ├── Get-TwitterLists_list.ps1
    │       ├── Get-TwitterMutes_UsersIds.ps1
    │       ├── Get-TwitterMutes_UsersList.ps1
    │       ├── Get-TwitterOauth_Authenticate.ps1
    │       ├── Get-TwitterOauth_Authorize.ps1
    │       ├── Get-TwitterSavedSearches_List.ps1
    │       ├── Get-TwitterSavedSearches_Show_Id.ps1
    │       ├── Get-TwitterStatuses_Lookup.ps1
    │       ├── Get-TwitterStatuses_RetweetersIds.ps1
    │       ├── Get-TwitterStatuses_RetweetsOfMe.ps1
    │       ├── Get-TwitterStatuses_Retweets_Id.ps1
    │       ├── Get-TwitterStatuses_Sample.ps1
    │       ├── Get-TwitterStatuses_Show_Id.ps1
    │       ├── Get-TwitterTrends_Available.ps1
    │       ├── Get-TwitterTrends_Closest.ps1
    │       ├── Get-TwitterTrends_Place.ps1
    │       ├── Get-TwitterUsers_Lookup.ps1
    │       ├── Get-TwitterUsers_ProfileBanner.ps1
    │       ├── Get-TwitterUsers_Search.ps1
    │       ├── Get-TwitterUsers_Show.ps1
    │       ├── Get-TwitterUsers_Suggestions.ps1
    │       ├── Get-TwitterUsers_Suggestions_Slug.ps1
    │       ├── Get-TwitterUsers_Suggestions_SlugMembers.ps1
    │       ├── Remove-TwitterCustomProfiles_Destroy.ps1
    │       ├── Send-TwitterAccount_RemoveProfileBanner.ps1
    │       ├── Send-TwitterAccount_Settings.ps1
    │       ├── Send-TwitterAccount_UpdateProfile.ps1
    │       ├── Send-TwitterAccount_UpdateProfileBackgroundImage.ps1
    │       ├── Send-TwitterAccount_UpdateProfileBanner.ps1
    │       ├── Send-TwitterAccount_UpdateProfileImage.ps1
    │       ├── Send-TwitterBlocks_Create.ps1
    │       ├── Send-TwitterBlocks_Destroy.ps1
    │       ├── Send-TwitterCollections_Create.ps1
    │       ├── Send-TwitterCollections_Destroy.ps1
    │       ├── Send-TwitterCollections_EntriesAdd.ps1
    │       ├── Send-TwitterCollections_EntriesCurate.ps1
    │       ├── Send-TwitterCollections_EntriesMove.ps1
    │       ├── Send-TwitterCollections_EntriesRemove.ps1
    │       ├── Send-TwitterCollections_Update.ps1
    │       ├── Send-TwitterCustomProfiles_New.Json.ps1
    │       ├── Send-TwitterDirectMessages_IndicateTyping.ps1
    │       ├── Send-TwitterDirectMessages_MarkRead.ps1
    │       ├── Send-TwitterDirectMessages_WelcomeMessagesNew.ps1
    │       ├── Send-TwitterDirectMessages_WelcomeMessagesRulesNew.ps1
    │       ├── Send-TwitterFavorites_Create.ps1
    │       ├── Send-TwitterFavorites_Destroy.ps1
    │       ├── Send-TwitterFriendships_Create.ps1
    │       ├── Send-TwitterFriendships_Destroy.ps1
    │       ├── Send-TwitterFriendships_Update.ps1
    │       ├── Send-TwitterLists_Create.ps1
    │       ├── Send-TwitterLists_Destroy.ps1
    │       ├── Send-TwitterLists_MembersCreate.ps1
    │       ├── Send-TwitterLists_MembersCreateAll.ps1
    │       ├── Send-TwitterLists_MembersDestroy.ps1
    │       ├── Send-TwitterLists_MembersDestroyAll.ps1
    │       ├── Send-TwitterLists_SubscribersCreate.ps1
    │       ├── Send-TwitterLists_SubscribersDestroy.ps1
    │       ├── Send-TwitterLists_Update.ps1
    │       ├── Send-TwitterMedia_MetadataCreate.ps1
    │       ├── Send-TwitterMedia_SubtitlesCreate.ps1
    │       ├── Send-TwitterMedia_SubtitlesDelete.ps1
    │       ├── Send-TwitterMedia_Upload.ps1
    │       ├── Send-TwitterMutes_UsersCreate.ps1
    │       ├── Send-TwitterMutes_UsersDestroy.ps1
    │       ├── Send-TwitterOauth2_InvalidateToken.ps1
    │       ├── Send-TwitterOauth2_Token.ps1
    │       ├── Send-TwitterOauth_AccessToken.ps1
    │       ├── Send-TwitterOauth_InvalidateToken.ps1
    │       ├── Send-TwitterOauth_RequestToken.ps1
    │       ├── Send-TwitterSavedSearches_Create.ps1
    │       ├── Send-TwitterSavedSearches_Destroy_Id.ps1
    │       ├── Send-TwitterStatuses_Destroy_Id.ps1
    │       ├── Send-TwitterStatuses_Filter.ps1
    │       ├── Send-TwitterStatuses_Retweet_Id.ps1
    │       ├── Send-TwitterStatuses_Unretweet_Id.ps1
    │       ├── Send-TwitterStatuses_Update.ps1
    │       ├── Send-TwitterStatuses_UpdateWithMedia.ps1
    │       └── Send-TwitterUsers_ReportSpam.ps1
├── README.md
├── Tests
    ├── PSScriptAnalyzer.Tests.ps1
    └── PSTwitterAPI.Tests.ps1
└── azure-pipelines.yml


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.dat
2 | *.log
3 | .vscode/
4 | output/
5 | testresults/
6 | APIHelper/helper/
7 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | // Available variables which can be used inside of strings.
 2 | // ${workspaceRoot}: the root folder of the team
 3 | // ${file}: the current opened file
 4 | // ${relativeFile}: the current opened file relative to workspaceRoot
 5 | // ${fileBasename}: the current opened file's basename
 6 | // ${fileDirname}: the current opened file's dirname
 7 | // ${fileExtname}: the current opened file's extension
 8 | // ${cwd}: the current working directory of the spawned process
 9 | {
10 |     // See https://go.microsoft.com/fwlink/?LinkId=733558
11 |     // for the documentation about the tasks.json format
12 | 	"version": "2.0.0",
13 | 
14 |     // Start PowerShell
15 |     "windows": {
16 |         "command": "${env:windir}/System32/WindowsPowerShell/v1.0/powershell.exe",
17 |         //"command": "${env:ProgramFiles}/PowerShell/6.0.0/powershell.exe",
18 |         "args": [ "-NoProfile", "-ExecutionPolicy", "Bypass" ]
19 |     },
20 |     "linux": {
21 |         "command": "/usr/bin/powershell",
22 |         "args": [ "-NoProfile" ]
23 |     },
24 |     "osx": {
25 |         "command": "/usr/local/bin/powershell",
26 |         "args": [ "-NoProfile" ]
27 |     },
28 | 
29 |     // Associate with test task runner
30 |     "tasks": [
31 |         {
32 |             "taskName": "Test",
33 |             "suppressTaskName": true,
34 |             "isTestCommand": true,
35 |             "args": [
36 |                 "Write-Host 'Invoke-Build -Task Test'; $ProgressPreference = 'SilentlyContinue'; Invoke-Build -Task Test;",
37 |                 "Invoke-Command { Write-Host 'Completed Test task in task runner.' }"
38 |             ],
39 |             "problemMatcher": "$pester"
40 |         }
41 | 	]
42 | }
43 | 


--------------------------------------------------------------------------------
/APIHelper/twitter_api.json:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkellerman/PSTwitterAPI/fae3e4fd11a083145f54d4d67a25a73a330223b8/APIHelper/twitter_api.json


--------------------------------------------------------------------------------
/PSTwitterAPI.bootstrap.ps1:
--------------------------------------------------------------------------------
 1 | using namespace Microsoft.PowerShell.Commands
 2 | [CmdletBinding()]
 3 | param(
 4 |     #
 5 |     [ValidateSet("CurrentUser", "AllUsers")]
 6 |     $Scope = "CurrentUser"
 7 | )
 8 | 
 9 | [ModuleSpecification[]]$RequiredModules = @(
10 |     @{ ModuleName = "InvokeBuild"; RequiredVersion = "5.4.2" }
11 |     @{ ModuleName = "Pester"; RequiredVersion = "4.4.4" }
12 |     @{ ModuleName = "BuildHelpers"; RequiredVersion = "2.0.3" }
13 |     @{ ModuleName = "PSScriptAnalyzer"; RequiredVersion = "1.17.1" }
14 | )
15 | 
16 | $Policy = (Get-PSRepository PSGallery).InstallationPolicy
17 | Set-PSRepository PSGallery -InstallationPolicy Trusted
18 | 
19 | try {
20 |     $RequiredModules | Install-Module -Scope $Scope -Repository PSGallery -SkipPublisherCheck -Verbose
21 | } finally {
22 |     Set-PSRepository PSGallery -InstallationPolicy $Policy
23 | }
24 | 
25 | $RequiredModules | Import-Module


--------------------------------------------------------------------------------
/PSTwitterAPI/PSTwitterAPI.psd1:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkellerman/PSTwitterAPI/fae3e4fd11a083145f54d4d67a25a73a330223b8/PSTwitterAPI/PSTwitterAPI.psd1


--------------------------------------------------------------------------------
/PSTwitterAPI/PSTwitterAPI.psm1:
--------------------------------------------------------------------------------
 1 | $Script:OAuthCollection = [System.Collections.ArrayList]@()
 2 | 
 3 | $Script:EndPointBaseUrl = 'https://api.twitter.com/1.1'
 4 | $Script:EndPointFileFormat = 'json'
 5 | 
 6 | $Script:CmdletBindingParameters = @('Verbose','Debug','ErrorAction','WarningAction','InformationAction','ErrorVariable','WarningVariable','InformationVariable','OutVariable','OutBuffer','PipelineVariable')
 7 | 
 8 | #Get public and private function definition files.
 9 | $Public = @( Get-ChildItem -Path $PSScriptRoot\public\*.ps1 -Recurse -ErrorAction SilentlyContinue )
10 | $Private = @( Get-ChildItem -Path $PSScriptRoot\private\*.ps1 -ErrorAction SilentlyContinue )
11 | 
12 | #Dot source the files.
13 | Foreach ($import in @($Public + $Private)) {
14 |     Try {
15 |         . $import.fullname
16 |     }
17 |     Catch {
18 |         Write-Error -Message "Failed to import function $($import.fullname): $_"
19 |     }
20 | }
21 | 
22 | Export-ModuleMember -Function $Public.Basename
23 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/private/ConvertFrom-RateLimitStatus.ps1:
--------------------------------------------------------------------------------
 1 | function ConvertFrom-RateLimitStatus ($RateLimitStatus) {
 2 | 
 3 |     $Eposh = Get-Eposh
 4 | 
 5 |     $RateLimitStatus.resources.PSObject.Properties | ForEach-Object {
 6 |         $_.value | ForEach-Object {
 7 |             $_.PSObject.Properties | ForEach-Object {
 8 |                 $_ | Select-Object @{ n='accesstoken'; e={ $RateLimitStatus.rate_limit_context.access_token }},
 9 |                                    @{ n='resource'; e={ $_.name }},
10 |                                    @{ n='limit'; e={ $_.value.limit }},
11 |                                    @{ n='remaining'; e={ $_.value.remaining }},
12 |                                    @{ n='reset'; e={ $_.value.reset }}
13 |             }
14 |         }
15 |     }
16 | 
17 |     # No idea why, but '/statuses/update' is missing from the RateLimitStatus result.
18 |     "/statuses/update" | Select-Object @{ n='accesstoken'; e={ $RateLimitStatus.rate_limit_context.access_token }},
19 |                                        @{ n='resource'; e={ $_ }},
20 |                                        @{ n='limit'; e={ 15 }},
21 |                                        @{ n='remaining'; e={ 15 }},
22 |                                        @{ n='reset'; e={ $Eposh.TotalSeconds }}
23 | 
24 | }


--------------------------------------------------------------------------------
/PSTwitterAPI/private/Get-Eposh.ps1:
--------------------------------------------------------------------------------
 1 | function Get-Eposh {
 2 | 
 3 |     [CmdletBinding()]
 4 |     Param (
 5 |         [int]$Eposh
 6 |     )
 7 | 
 8 |     Process {
 9 | 
10 |         If ($Eposh) {
11 |             [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970').AddSeconds($Eposh))
12 |         } Else {
13 |             $unixEpochStart = New-Object DateTime 1970,1,1,0,0,0,([DateTimeKind]::Utc)
14 |             [DateTime]::UtcNow - $unixEpochStart
15 |         }
16 | 
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/PSTwitterAPI/public/Get-TwitterOAuthSettings.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterOAuthSettings {
 2 | 
 3 |     [CmdletBinding()]
 4 |     Param($Resource, $AccessToken, [switch]$Quiet)
 5 | 
 6 |     If ($Resource) {
 7 | 
 8 |         # Get the next available OAuth with available resources
 9 |         $RateLimitStatus =  $Script:OAuthCollection.RateLimitStatus |
10 |                             Where-Object { $_.resource -eq "$Resource" } |
11 |                             Sort-Object @{expression="remaining";Descending=$true}, @{expression="reset";Ascending=$true} |
12 |                             Select-Object -First 1 | 
13 |                             ForEach-Object { $_.remaining += -1;  Return $_ }
14 |         
15 |         Write-Verbose "resource: $($RateLimitStatus.resource), limit: $($RateLimitStatus.limit), remaining: $($RateLimitStatus.remaining), reset: $($RateLimitStatus.reset)"
16 | 
17 |         $AccessToken = $RateLimitStatus.AccessToken
18 | 
19 |         If ($RateLimitStatus.remaining -lt 0) {
20 | 
21 |             # Refresh the RateLimitStatus so we throttle an accurate value
22 |             $OAuthSettings = $Script:OAuthCollection.Where({$_.AccessToken -eq $AccessToken}) | Select-Object -First 1
23 |             $OAuthSettings = Set-TwitterOAuthSettings -ApiKey $OAuthSettings.ApiKey -ApiSecret $OAuthSettings.ApiSecret -AccessToken $OAuthSettings.AccessToken -AccessTokenSecret $OAuthSettings.AccessTokenSecret -PassThru -Force
24 | 
25 |             $RateLimitStatus  = $OAuthSettings.RateLimitStatus | Where-Object { $_.resource -eq "$Resource" } | 
26 |                                 ForEach-Object { $_.remaining += -1;  Return $_ }
27 | 
28 |             If ($RateLimitStatus.remaining -lt 0) {
29 | 
30 |                 # Throttle... you're going way too fast cowboy!
31 |                 $SleepSeconds = $RateLimitStatus.reset - (Get-Eposh).TotalSeconds + 1
32 |                 Write-Warning "Throttling for ${SleepSeconds} seconds."
33 |                 Start-Sleep -Seconds $SleepSeconds 
34 | 
35 |             }
36 | 
37 |         }
38 | 
39 | 
40 |     }
41 | 
42 | 
43 |     If ($AccessToken) {
44 |         $OAuthSettings = $Script:OAuthCollection.Where({$_.AccessToken -eq $AccessToken}) | Select-Object -First 1
45 |     } Else {
46 |         $OAuthSettings = $Script:OAuthCollection | Select-Object -First 1
47 |     }
48 | 
49 | 
50 |     If ($OAuthSettings) {
51 |         Write-Verbose "Using AccessToken '$($OAuthSettings.AccessToken)'"
52 |         $OAuthSettings = @{
53 |             ApiKey = $OAuthSettings.ApiKey
54 |             ApiSecret = $OAuthSettings.ApiSecret
55 |             AccessToken = $OAuthSettings.AccessToken
56 |             AccessTokenSecret = $OAuthSettings.AccessTokenSecret
57 |         }
58 |         Return $OAuthSettings
59 |     }
60 | 
61 |     If ($Quiet.IsPresent -eq $false) {
62 |         Throw "No OAuthSettings was found. Use 'Set-TwitterOAuthSettings' to set PSTwitterAPI ApiKey & Token."
63 |     }
64 | 
65 | }
66 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/Invoke-TwitterAPI.ps1:
--------------------------------------------------------------------------------
 1 | function Invoke-TwitterAPI {
 2 | 
 3 |     [CmdletBinding()]
 4 |     Param(
 5 |         [Parameter(Mandatory)]
 6 |         [string]$ResourceUrl,
 7 |         [Parameter(Mandatory)]
 8 |         [string]$Method,
 9 |         [Parameter(Mandatory=$false)]
10 |         $Parameters,
11 |         [Parameter(Mandatory=$false)]
12 |         $Body,
13 |         [Parameter(Mandatory)]
14 |         $OAuthSettings
15 |     )
16 | 
17 |     $OAuthParameters_Params = @{}
18 |     $OAuthParameters_Params['ApiKey'] = $OAuthSettings.ApiKey
19 |     $OAuthParameters_Params['ApiSecret'] = $OAuthSettings.ApiSecret
20 |     $OAuthParameters_Params['AccessToken'] = $OAuthSettings.AccessToken
21 |     $OAuthParameters_Params['AccessTokenSecret'] = $OAuthSettings.AccessTokenSecret
22 |     $OAuthParameters_Params['Method'] = $Method
23 |     $OAuthParameters_Params['ResourceUrl'] = $ResourceUrl
24 |     $OAuthParameters_Params['Parameters'] = $Parameters
25 |     $OAuthParameters_Params['Body'] = $Body
26 |     $OAuthParameters = Get-OAuthParameters @OAuthParameters_Params
27 | 
28 |     $RestMethod_Params = @{}
29 |     $RestMethod_Params['Uri'] = $OAuthParameters.endpoint_url
30 |     $RestMethod_Params['Method'] = $OAuthParameters.endpoint_method
31 |     $RestMethod_Params['Headers'] = @{ 'Authorization' = $OAuthParameters.endpoint_authorization }
32 |     $RestMethod_Params['ContentType'] = $OAuthParameters.endpoint_contenttype
33 |     $RestMethod_Params['Body'] = $OAuthParameters.endpoint_body
34 |     Invoke-RestMethod @RestMethod_Params
35 | 
36 | }


--------------------------------------------------------------------------------
/PSTwitterAPI/public/Send-TwitterDirectMessages_EventsNew.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterDirectMessages_EventsNew {
 2 | <#
 3 | .SYNOPSIS
 4 |     Sending and receiving events
 5 | 
 6 | .DESCRIPTION
 7 |     POST direct_messages/events/new (message_create)
 8 |     
 9 |     Publishes a new message_create event resulting in a Direct Message sent to a specified user from the authenticating user. Returns an event if successful. Supports publishing Direct Messages with optional Quick Reply and media attachment. Replaces behavior currently provided by POST direct_messages/new.
10 |     
11 |     Requires a JSON POST body and Content-Type header to be set to application/json. Setting Content-Length may also be required if it is not automatically.
12 | 
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/direct-messages/sending-and-receiving/api-reference/new-event
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$type = 'message_create',
22 |         [string]$recipient_id,
23 |         [string]$text
24 |     )
25 |     Begin {
26 | 
27 |         [hashtable]$Parameters = $PSBoundParameters
28 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
29 | 
30 |         [string]$Method      = 'POST'
31 |         [string]$Resource    = '/direct_messages/events/new'
32 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/events/new.json'
33 | 
34 |     }
35 |     Process {
36 | 
37 |         $Body = @{ 
38 |             event = @{
39 |                 type = $type
40 |                 message_create = @{
41 |                     target = @{ recipient_id = $Parameters['recipient_id'] }
42 |                     message_data = @{ text = $Parameters['text'] }
43 |                 }
44 |             }
45 |         }
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Body $Body -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/Set-TwitterOAuthSettings.ps1:
--------------------------------------------------------------------------------
 1 | function Set-TwitterOAuthSettings {
 2 | 
 3 |     [CmdletBinding()]
 4 |     Param(
 5 |         $ApiKey,
 6 |         $ApiSecret,
 7 |         $AccessToken,
 8 |         $AccessTokenSecret,
 9 |         [switch]$PassThru,
10 |         [switch]$Force
11 |     )
12 |     Process {
13 | 
14 |         If ($OAuthSettings = Get-TwitterOAuthSettings -AccessToken $AccessToken -Quiet) {
15 |             If ($Force) {
16 |                 [void]$Script:OAuthCollection.Remove($OAuthSettings)
17 |             } Else {
18 |                 Write-Warning "OAuthSettings with AccessToken '${AccessToken}' already exists."
19 |             }
20 |         }
21 | 
22 |         $OAuthSettings = @{
23 |             ApiKey = $ApiKey
24 |             ApiSecret = $ApiSecret
25 |             AccessToken = $AccessToken
26 |             AccessTokenSecret = $AccessTokenSecret
27 |         }
28 | 
29 |         $RateLimitStatus = Get-TwitterApplication_RateLimitStatus -OAuthSettings $OAuthSettings
30 |         If ($RateLimitStatus.rate_limit_context.access_token -ne $AccessToken) { Throw 'RateLimitStatus was returned for the wrong AccessToken.'}
31 |         
32 |         $OAuthSettings['RateLimitStatus'] = ConvertFrom-RateLimitStatus -RateLimitStatus $RateLimitStatus
33 | 
34 |         [void]$Script:OAuthCollection.Add($OAuthSettings)
35 | 
36 |         If ($PassThru) { $OAuthSettings }
37 | 
38 |     }
39 | 
40 | }


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterAccount_Settings.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterAccount_Settings {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     GET account/settings
 8 |     
 9 |     Returns settings (including current trend, geo and sleep time information) for the authenticating user.
10 | 
11 | 
12 | .NOTES
13 |     This helper function was generated by the information provided here:
14 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/get-account-settings
15 | 
16 | #>
17 |     [CmdletBinding()]
18 |     Param(
19 |         
20 |     )
21 |     Begin {
22 | 
23 |         [hashtable]$Parameters = $PSBoundParameters
24 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
25 | 
26 |         [string]$Method      = 'GET'
27 |         [string]$Resource    = '/account/settings'
28 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/account/settings.json'
29 | 
30 |     }
31 |     Process {
32 | 
33 |         # Find & Replace any ResourceUrl parameters.
34 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
35 |         ForEach ($UrlParameter in $UrlParameters) {
36 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
37 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
38 |         }
39 | 
40 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
41 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
42 | 
43 |     }
44 |     End {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterBlocks_Ids.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterBlocks_Ids {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     GET blocks/ids
 8 |     
 9 |     Returns an array of numeric user ids the authenticating user is blocking.
10 |     
11 |     Important This method is cursored, meaning your app must make multiple requests in order to receive all blocks correctly. See Using cursors to navigate collections for more details on how cursoring works.
12 | 
13 | .PARAMETER stringify_ids
14 |     Many programming environments will not consume Twitter IDs due to their size. Provide this option to have IDs returned as strings instead. Read more about Twitter IDs .
15 | 
16 | .PARAMETER cursor
17 |     Causes the list of IDs to be broken into pages of no more than 5000 IDs at a time. The number of IDs returned is not guaranteed to be 5000 as suspended users are filtered out after connections are queried. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
18 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth. See Using cursors to navigate collections for more information.
19 | 
20 | .NOTES
21 |     This helper function was generated by the information provided here:
22 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/get-blocks-ids
23 | 
24 | #>
25 |     [CmdletBinding()]
26 |     Param(
27 |         [string]$stringify_ids,
28 |         [string]$cursor
29 |     )
30 |     Begin {
31 | 
32 |         [hashtable]$Parameters = $PSBoundParameters
33 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
34 | 
35 |         [string]$Method      = 'GET'
36 |         [string]$Resource    = '/blocks/ids'
37 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/blocks/ids.json'
38 | 
39 |     }
40 |     Process {
41 | 
42 |         # Find & Replace any ResourceUrl parameters.
43 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
44 |         ForEach ($UrlParameter in $UrlParameters) {
45 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
46 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
47 |         }
48 | 
49 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
50 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
51 | 
52 |     }
53 |     End {
54 | 
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterBlocks_List.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterBlocks_List {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     GET blocks/list
 8 |     
 9 |     Returns a collection of user objects that the authenticating user is blocking.
10 |     
11 |     Important This method is cursored, meaning your app must make multiple requests in order to receive all blocks correctly. See Using cursors to navigate collections for more details on how cursoring works.
12 | 
13 | .PARAMETER include_entities
14 |     The entities node will not be included when set to false .
15 | 
16 | .PARAMETER skip_status
17 |     When set to either true , t or 1 statuses will not be included in the returned user objects.
18 | 
19 | .PARAMETER cursor
20 |     Causes the list of blocked users to be broken into pages of no more than 5000 IDs at a time. The number of IDs returned is not guaranteed to be 5000 as suspended users are filtered out after connections are queried. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
21 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth. See Using cursors to navigate collections for more information.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/get-blocks-list
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$include_entities,
31 |         [string]$skip_status,
32 |         [string]$cursor
33 |     )
34 |     Begin {
35 | 
36 |         [hashtable]$Parameters = $PSBoundParameters
37 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
38 | 
39 |         [string]$Method      = 'GET'
40 |         [string]$Resource    = '/blocks/list'
41 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/blocks/list.json'
42 | 
43 |     }
44 |     Process {
45 | 
46 |         # Find & Replace any ResourceUrl parameters.
47 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
48 |         ForEach ($UrlParameter in $UrlParameters) {
49 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
50 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
51 |         }
52 | 
53 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
54 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
55 | 
56 |     }
57 |     End {
58 | 
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterCollections_Entries.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterCollections_Entries {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET collections/entries
 8 |     
 9 |     Retrieve the identified Collection, presented as a list of the Tweets curated within.
10 |     
11 |     The response structure of this method differs significantly from timelines you may be used to working with elsewhere in the Twitter API.
12 |     
13 |     To navigate a Collection, use the position object of a response, which includes attributes for max_position, min_position, and was_truncated. was_truncated indicates whether additional Tweets exist in the collection outside of the range of the current request. To retrieve Tweets further back in time, use the value of min_position found in the current response as the max_position parameter in the next call to this endpoint.
14 | 
15 | .PARAMETER id
16 |     The identifier of the Collection for which to return results.
17 | 
18 | .PARAMETER count
19 |     Specifies the maximum number of results to include in the response. Specify a count between 1 and 200. A next_cursor value will be provided in the response if additional results are available.
20 | 
21 | .PARAMETER max_position
22 |     Returns results with a position value less than or equal to the specified position.
23 | 
24 | .PARAMETER min_position
25 |     Returns results with a position greater than the specified position.
26 | 
27 | .NOTES
28 |     This helper function was generated by the information provided here:
29 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/get-collections-entries
30 | 
31 | #>
32 |     [CmdletBinding()]
33 |     Param(
34 |         [string]$id,
35 |         [string]$count,
36 |         [string]$max_position,
37 |         [string]$min_position
38 |     )
39 |     Begin {
40 | 
41 |         [hashtable]$Parameters = $PSBoundParameters
42 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
43 | 
44 |         [string]$Method      = 'GET'
45 |         [string]$Resource    = '/collections/entries'
46 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/entries.json'
47 | 
48 |     }
49 |     Process {
50 | 
51 |         # Find & Replace any ResourceUrl parameters.
52 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
53 |         ForEach ($UrlParameter in $UrlParameters) {
54 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
55 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
56 |         }
57 | 
58 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
59 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
60 | 
61 |     }
62 |     End {
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterCollections_List.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterCollections_List {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET collections/list
 8 |     
 9 |     Find Collections created by a specific user or containing a specific curated Tweet.
10 |     
11 |     Results are organized in a cursored collection.
12 | 
13 | .PARAMETER user_id
14 |     The ID of the user for whom to return results.
15 | 
16 | .PARAMETER screen_name
17 |     The screen name of the user for whom to return results.
18 | 
19 | .PARAMETER tweet_id
20 |     The identifier of the Tweet for which to return results.
21 | 
22 | .PARAMETER count
23 |     Specifies the maximum number of results to include in the response. Specify a count between 1 and 200. A next_cursor value will be provided in the response if additional results are available.
24 | 
25 | .PARAMETER cursor
26 |     A string identifying the segment of the current result set to retrieve. Values for this parameter are yielded in the cursors node attached to response objects. Usage of the count parameter affects cursoring.
27 | 
28 | .NOTES
29 |     This helper function was generated by the information provided here:
30 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/get-collections-list
31 | 
32 | #>
33 |     [CmdletBinding()]
34 |     Param(
35 |         [string]$user_id,
36 |         [string]$screen_name,
37 |         [string]$tweet_id,
38 |         [string]$count,
39 |         [string]$cursor
40 |     )
41 |     Begin {
42 | 
43 |         [hashtable]$Parameters = $PSBoundParameters
44 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
45 | 
46 |         [string]$Method      = 'GET'
47 |         [string]$Resource    = '/collections/list'
48 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/list.json'
49 | 
50 |     }
51 |     Process {
52 | 
53 |         # Find & Replace any ResourceUrl parameters.
54 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
55 |         ForEach ($UrlParameter in $UrlParameters) {
56 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
57 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
58 |         }
59 | 
60 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
61 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
62 | 
63 |     }
64 |     End {
65 | 
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterCollections_Show.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterCollections_Show {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET collections/show
 8 |     
 9 |     Retrieve information associated with a specific Collection.
10 | 
11 | .PARAMETER id
12 |     The identifier of the Collection for which to return results.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/get-collections-show
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/collections/show'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/show.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterCustomProfiles_List.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterCustomProfiles_List {
 2 | <#
 3 | .SYNOPSIS
 4 |     Custom profiles
 5 | 
 6 | .DESCRIPTION
 7 |     GET custom_profiles/list
 8 |     
 9 |     Retrieves all custom profiles for the authenticated account. Default page size is 20.
10 | 
11 | .PARAMETER count (optional)
12 |     
13 | 
14 | .PARAMETER cursor (optional)
15 |     
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/direct-messages/custom-profiles/api-reference/get-profile-list
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$count,
25 |         [string]$cursor
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/custom_profiles/list'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/custom_profiles/list.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterCustomProfiles__Id.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterCustomProfiles__Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Custom profiles
 5 | 
 6 | .DESCRIPTION
 7 |     GET custom_profiles/:id
 8 |     
 9 |     Returns a custom profile that was created with POST custom_profiles/new.json.
10 | 
11 | .PARAMETER id (required)
12 |     
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/direct-messages/custom-profiles/api-reference/get-profile
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/custom_profiles/:id'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/custom_profiles/:id.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterDirectMessages_EventsList.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterDirectMessages_EventsList {
 2 | <#
 3 | .SYNOPSIS
 4 |     Sending and receiving events
 5 | 
 6 | .DESCRIPTION
 7 |     GET direct_messages/events/list
 8 |     
 9 |     Returns all Direct Message events (both sent and received) within the last 30 days. Sorted in reverse-chronological order.
10 | 
11 | .PARAMETER count (optional)
12 |     
13 | 
14 | .PARAMETER cursor (optional)
15 |     
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/direct-messages/sending-and-receiving/api-reference/list-events
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$count,
25 |         [string]$cursor
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/direct_messages/events/list'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/events/list.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterDirectMessages_EventsShow.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterDirectMessages_EventsShow {
 2 | <#
 3 | .SYNOPSIS
 4 |     Sending and receiving events
 5 | 
 6 | .DESCRIPTION
 7 |     GET direct_messages/events/show
 8 |     
 9 |     Returns a single Direct Message event by the given id.
10 | 
11 | .PARAMETER id (required)
12 |     
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/direct-messages/sending-and-receiving/api-reference/get-event
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/direct_messages/events/show'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/events/show.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterDirectMessages_WelcomeMessagesList.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterDirectMessages_WelcomeMessagesList {
 2 | <#
 3 | .SYNOPSIS
 4 |     Welcome Messages
 5 | 
 6 | .DESCRIPTION
 7 |     GET direct_messages/welcome_messages/list
 8 |     
 9 |     Returns a list of Welcome Messages.
10 | 
11 | .PARAMETER count (optional)
12 |     
13 | 
14 | .PARAMETER cursor (optional)
15 |     
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/direct-messages/welcome-messages/api-reference/list-welcome-messages
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$count,
25 |         [string]$cursor
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/direct_messages/welcome_messages/list'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/welcome_messages/list.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterDirectMessages_WelcomeMessagesRulesList.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterDirectMessages_WelcomeMessagesRulesList {
 2 | <#
 3 | .SYNOPSIS
 4 |     Welcome Messages
 5 | 
 6 | .DESCRIPTION
 7 |     GET direct_messages/welcome_messages/rules/list
 8 |     
 9 |     Returns a list of Welcome Message Rules.
10 | 
11 | .PARAMETER count (optional)
12 |     
13 | 
14 | .PARAMETER cursor (optional)
15 |     
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/direct-messages/welcome-messages/api-reference/list-welcome-message-rules
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$count,
25 |         [string]$cursor
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/direct_messages/welcome_messages/rules/list'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/welcome_messages/rules/list.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterDirectMessages_WelcomeMessagesRulesShow.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterDirectMessages_WelcomeMessagesRulesShow {
 2 | <#
 3 | .SYNOPSIS
 4 |     Welcome Messages
 5 | 
 6 | .DESCRIPTION
 7 |     GET direct_messages/welcome_messages/rules/show
 8 |     
 9 |     Returns a Welcome Message Rule by the given id.
10 | 
11 | .PARAMETER id (required)
12 |     
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/direct-messages/welcome-messages/api-reference/get-welcome-message-rule
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/direct_messages/welcome_messages/rules/show'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/welcome_messages/rules/show.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterDirectMessages_WelcomeMessagesShow.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterDirectMessages_WelcomeMessagesShow {
 2 | <#
 3 | .SYNOPSIS
 4 |     Welcome Messages
 5 | 
 6 | .DESCRIPTION
 7 |     GET direct_messages/welcome_messages/show
 8 |     
 9 |     Returns a Welcome Message by the given id.
10 | 
11 | .PARAMETER id (required)
12 |     
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/direct-messages/welcome-messages/api-reference/get-welcome-message
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/direct_messages/welcome_messages/show'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/welcome_messages/show.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterFavorites_List.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterFavorites_List {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET favorites/list
 8 |     
 9 |     Note: favorites are now known as likes.
10 |     
11 |     Returns the 20 most recent Tweets liked by the authenticating or specified user.
12 | 
13 | .PARAMETER user_id
14 |     The ID of the user for whom to return results.
15 | 
16 | .PARAMETER screen_name
17 |     The screen name of the user for whom to return results.
18 | 
19 | .PARAMETER count
20 |     Specifies the number of records to retrieve. Must be less than or equal to 200; defaults to 20. The value of count is best thought of as a limit to the number of Tweets to return because suspended or deleted content is removed after the count has been applied.
21 | 
22 | .PARAMETER since_id
23 |     Returns results with an ID greater than (that is, more recent than) the specified ID. There are limits to the number of Tweets which can be accessed through the API. If the limit of Tweets has occured since the since_id, the since_id will be forced to the oldest ID available.
24 | 
25 | .PARAMETER max_id
26 |     Returns results with an ID less than (that is, older than) or equal to the specified ID.
27 | 
28 | .PARAMETER include_entities
29 |     The entities node will be omitted when set to false .
30 | 
31 | .NOTES
32 |     This helper function was generated by the information provided here:
33 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/get-favorites-list
34 | 
35 | #>
36 |     [CmdletBinding()]
37 |     Param(
38 |         [string]$user_id,
39 |         [string]$screen_name,
40 |         [string]$count,
41 |         [string]$since_id,
42 |         [string]$max_id,
43 |         [string]$include_entities
44 |     )
45 |     Begin {
46 | 
47 |         [hashtable]$Parameters = $PSBoundParameters
48 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
49 | 
50 |         [string]$Method      = 'GET'
51 |         [string]$Resource    = '/favorites/list'
52 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/favorites/list.json'
53 | 
54 |     }
55 |     Process {
56 | 
57 |         # Find & Replace any ResourceUrl parameters.
58 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
59 |         ForEach ($UrlParameter in $UrlParameters) {
60 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
61 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
62 |         }
63 | 
64 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
65 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
66 | 
67 |     }
68 |     End {
69 | 
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterFriendships_Incoming.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterFriendships_Incoming {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET friendships/incoming
 8 |     
 9 |     Returns a collection of numeric IDs for every user who has a pending request to follow the authenticating user.
10 | 
11 | .PARAMETER cursor
12 |     Causes the list of connections to be broken into pages of no more than 5000 IDs at a time. The number of IDs returned is not guaranteed to be 5000 as suspended users are filtered out after connections are queried. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
13 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth.
14 | 
15 | .PARAMETER stringify_ids
16 |     Many programming environments will not consume our Tweet ids due to their size. Provide this option to have ids returned as strings instead.
17 | 
18 | .NOTES
19 |     This helper function was generated by the information provided here:
20 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-incoming
21 | 
22 | #>
23 |     [CmdletBinding()]
24 |     Param(
25 |         [string]$cursor,
26 |         [string]$stringify_ids
27 |     )
28 |     Begin {
29 | 
30 |         [hashtable]$Parameters = $PSBoundParameters
31 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
32 | 
33 |         [string]$Method      = 'GET'
34 |         [string]$Resource    = '/friendships/incoming'
35 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/incoming.json'
36 | 
37 |     }
38 |     Process {
39 | 
40 |         # Find & Replace any ResourceUrl parameters.
41 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
42 |         ForEach ($UrlParameter in $UrlParameters) {
43 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
44 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
45 |         }
46 | 
47 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
48 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
49 | 
50 |     }
51 |     End {
52 | 
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterFriendships_Lookup.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterFriendships_Lookup {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET friendships/lookup
 8 |     
 9 |     Returns the relationships of the authenticating user to the comma-separated list of up to 100 screen_names or user_ids provided. Values for connections can be: following, following_requested, followed_by, none, blocking, muting.
10 | 
11 | .PARAMETER screen_name
12 |     A comma separated list of screen names, up to 100 are allowed in a single request.
13 | 
14 | .PARAMETER user_id
15 |     A comma separated list of user IDs, up to 100 are allowed in a single request.
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-lookup
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$screen_name,
25 |         [string]$user_id
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/friendships/lookup'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/lookup.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterFriendships_NoRetweetsIds.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterFriendships_NoRetweetsIds {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET friendships/no_retweets/ids
 8 |     
 9 |     Returns a collection of user_ids that the currently authenticated user does not want to receive retweets from.
10 |     
11 |     Use POST friendships / update to set the "no retweets" status for a given user account on behalf of the current user.
12 | 
13 | .PARAMETER stringify_ids
14 |     Some programming environments will not consume Twitter IDs due to their size. Provide this option to have IDs returned as strings instead. Read more about Twitter IDs. This parameter is important to use in Javascript environments.
15 | 
16 | .NOTES
17 |     This helper function was generated by the information provided here:
18 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-no_retweets-ids
19 | 
20 | #>
21 |     [CmdletBinding()]
22 |     Param(
23 |         [string]$stringify_ids
24 |     )
25 |     Begin {
26 | 
27 |         [hashtable]$Parameters = $PSBoundParameters
28 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
29 | 
30 |         [string]$Method      = 'GET'
31 |         [string]$Resource    = '/friendships/no_retweets/ids'
32 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/no_retweets/ids.json'
33 | 
34 |     }
35 |     Process {
36 | 
37 |         # Find & Replace any ResourceUrl parameters.
38 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
39 |         ForEach ($UrlParameter in $UrlParameters) {
40 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
41 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
42 |         }
43 | 
44 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
45 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
46 | 
47 |     }
48 |     End {
49 | 
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterFriendships_Outgoing.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterFriendships_Outgoing {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET friendships/outgoing
 8 |     
 9 |     Returns a collection of numeric IDs for every protected user for whom the authenticating user has a pending follow request.
10 | 
11 | .PARAMETER cursor
12 |     Causes the list of connections to be broken into pages of no more than 5000 IDs at a time. The number of IDs returned is not guaranteed to be 5000 as suspended users are filtered out after connections are queried. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
13 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth. See Using cursors to navigate collections for more information.
14 | 
15 | .PARAMETER stringify_ids
16 |     Some programming environments will not consume Twitter IDs due to their size. Provide this option to have IDs returned as strings instead. More about Twitter IDs.
17 | 
18 | .NOTES
19 |     This helper function was generated by the information provided here:
20 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-outgoing
21 | 
22 | #>
23 |     [CmdletBinding()]
24 |     Param(
25 |         [string]$cursor,
26 |         [string]$stringify_ids
27 |     )
28 |     Begin {
29 | 
30 |         [hashtable]$Parameters = $PSBoundParameters
31 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
32 | 
33 |         [string]$Method      = 'GET'
34 |         [string]$Resource    = '/friendships/outgoing'
35 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/outgoing.format'
36 | 
37 |     }
38 |     Process {
39 | 
40 |         # Find & Replace any ResourceUrl parameters.
41 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
42 |         ForEach ($UrlParameter in $UrlParameters) {
43 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
44 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
45 |         }
46 | 
47 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
48 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
49 | 
50 |     }
51 |     End {
52 | 
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterFriendships_Show.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterFriendships_Show {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET friendships/show
 8 |     
 9 |     Returns detailed information about the relationship between two arbitrary users.
10 | 
11 | .PARAMETER source_id
12 |     The user_id of the subject user.
13 | 
14 | .PARAMETER source_screen_name
15 |     The screen_name of the subject user.
16 | 
17 | .PARAMETER target_id
18 |     The user_id of the target user.
19 | 
20 | .PARAMETER target_screen_name
21 |     The screen_name of the target user.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-show
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$source_id,
31 |         [string]$source_screen_name,
32 |         [string]$target_id,
33 |         [string]$target_screen_name
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'GET'
41 |         [string]$Resource    = '/friendships/show'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/show.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterGeo_Id_PlaceId.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterGeo_Id_PlaceId {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get information about a place
 5 | 
 6 | .DESCRIPTION
 7 |     GET geo/id/:place_id
 8 |     
 9 |     Returns all the information about a known place.
10 | 
11 | .PARAMETER place_id
12 |     A place in the world. These IDs can be retrieved from geo/reverse_geocode.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/geo/place-information/api-reference/get-geo-id-place_id
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$place_id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/geo/id/:place_id'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/geo/id/:place_id.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterHelp_Configuration.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterHelp_Configuration {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get Twitter configuration details
 5 | 
 6 | .DESCRIPTION
 7 |     GET help/configuration
 8 |     
 9 |     Returns the current configuration used by Twitter including twitter.com slugs which are not usernames, maximum photo resolutions, and t.co shortened URL length.
10 |     
11 |     It is recommended applications request this endpoint when they are loaded, but no more than once a day.
12 | 
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/developer-utilities/configuration/api-reference/get-help-configuration
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/help/configuration'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/help/configuration.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterHelp_Languages.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterHelp_Languages {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get Twitter supported languages
 5 | 
 6 | .DESCRIPTION
 7 |     GET help/languages
 8 |     
 9 |     Returns the list of languages supported by Twitter along with the language code supported by Twitter.
10 |     
11 |     The language code may be formatted as ISO 639-1 alpha-2 (en), ISO 639-3 alpha-3 (msa), or ISO 639-1 alpha-2 combined with an ISO 3166-1 alpha-2 localization (zh-tw).
12 | 
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/developer-utilities/supported-languages/api-reference/get-help-languages
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/help/languages'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/help/languages.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterHelp_Privacy.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterHelp_Privacy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get Twitter's privacy policy
 5 | 
 6 | .DESCRIPTION
 7 |     GET help/privacy
 8 |     
 9 |     Returns Twitter's Privacy Policy.
10 | 
11 | 
12 | .NOTES
13 |     This helper function was generated by the information provided here:
14 |     https://developer.twitter.com/en/docs/developer-utilities/privacy-policy/api-reference/get-help-privacy
15 | 
16 | #>
17 |     [CmdletBinding()]
18 |     Param(
19 |         
20 |     )
21 |     Begin {
22 | 
23 |         [hashtable]$Parameters = $PSBoundParameters
24 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
25 | 
26 |         [string]$Method      = 'GET'
27 |         [string]$Resource    = '/help/privacy'
28 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/help/privacy.json'
29 | 
30 |     }
31 |     Process {
32 | 
33 |         # Find & Replace any ResourceUrl parameters.
34 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
35 |         ForEach ($UrlParameter in $UrlParameters) {
36 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
37 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
38 |         }
39 | 
40 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
41 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
42 | 
43 |     }
44 |     End {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterHelp_Tos.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterHelp_Tos {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get Twitter's terms of service
 5 | 
 6 | .DESCRIPTION
 7 |     GET help/tos
 8 |     
 9 |     Returns the Twitter Terms of Service. Note: these are not the same as the Developer Policy.
10 | 
11 | 
12 | .NOTES
13 |     This helper function was generated by the information provided here:
14 |     https://developer.twitter.com/en/docs/developer-utilities/terms-of-service/api-reference/get-help-tos
15 | 
16 | #>
17 |     [CmdletBinding()]
18 |     Param(
19 |         
20 |     )
21 |     Begin {
22 | 
23 |         [hashtable]$Parameters = $PSBoundParameters
24 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
25 | 
26 |         [string]$Method      = 'GET'
27 |         [string]$Resource    = '/help/tos'
28 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/help/tos.json'
29 | 
30 |     }
31 |     Process {
32 | 
33 |         # Find & Replace any ResourceUrl parameters.
34 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
35 |         ForEach ($UrlParameter in $UrlParameters) {
36 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
37 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
38 |         }
39 | 
40 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
41 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
42 | 
43 |     }
44 |     End {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterLists_Memberships.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterLists_Memberships {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     GET lists/memberships
 8 |     
 9 |     Returns the lists the specified user has been added to. If user_id or screen_name are not provided, the memberships for the authenticating user are returned.
10 | 
11 | .PARAMETER user_id
12 |     The ID of the user for whom to return results. Helpful for disambiguating when a valid user ID is also a valid screen name.
13 | 
14 | .PARAMETER screen_name
15 |     The screen name of the user for whom to return results. Helpful for disambiguating when a valid screen name is also a user ID.
16 | 
17 | .PARAMETER count
18 |     The amount of results to return per page. Defaults to 20. No more than 1000 results will ever be returned in a single page.
19 | 
20 | .PARAMETER cursor
21 |     Breaks the results into pages. Provide a value of -1 to begin paging. Provide values as returned in the response body's next_cursor and previous_cursor attributes to page back and forth in the list. It is recommended to always use cursors when the method supports them. See Cursoring for more information.
22 | 
23 | .PARAMETER filter_to_owned_lists
24 |     When set to true , t or 1 , will return just lists the authenticating user owns, and the user represented by user_id or screen_name is a member of.
25 | 
26 | .NOTES
27 |     This helper function was generated by the information provided here:
28 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/get-lists-memberships
29 | 
30 | #>
31 |     [CmdletBinding()]
32 |     Param(
33 |         [string]$user_id,
34 |         [string]$screen_name,
35 |         [string]$count,
36 |         [string]$cursor,
37 |         [string]$filter_to_owned_lists
38 |     )
39 |     Begin {
40 | 
41 |         [hashtable]$Parameters = $PSBoundParameters
42 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
43 | 
44 |         [string]$Method      = 'GET'
45 |         [string]$Resource    = '/lists/memberships'
46 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/memberships.json'
47 | 
48 |     }
49 |     Process {
50 | 
51 |         # Find & Replace any ResourceUrl parameters.
52 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
53 |         ForEach ($UrlParameter in $UrlParameters) {
54 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
55 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
56 |         }
57 | 
58 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
59 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
60 | 
61 |     }
62 |     End {
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterLists_Ownerships.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterLists_Ownerships {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     GET lists/ownerships
 8 |     
 9 |     Returns the lists owned by the specified Twitter user. Private lists will only be shown if the authenticated user is also the owner of the lists.
10 | 
11 | .PARAMETER user_id
12 |     The ID of the user for whom to return results. Helpful for disambiguating when a valid user ID is also a valid screen name.
13 | 
14 | .PARAMETER screen_name
15 |     The screen name of the user for whom to return results. Helpful for disambiguating when a valid screen name is also a user ID.
16 | 
17 | .PARAMETER count
18 |     The amount of results to return per page. Defaults to 20. No more than 1000 results will ever be returned in a single page.
19 | 
20 | .PARAMETER cursor
21 |     Breaks the results into pages. Provide a value of -1 to begin paging. Provide values as returned in the response body's next_cursor and previous_cursor attributes to page back and forth in the list. It is recommended to always use cursors when the method supports them. See Cursoring for more information.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/get-lists-ownerships
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$user_id,
31 |         [string]$screen_name,
32 |         [string]$count,
33 |         [string]$cursor
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'GET'
41 |         [string]$Resource    = '/lists/ownerships'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/ownerships.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterLists_Show.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterLists_Show {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     GET lists/show
 8 |     
 9 |     Returns the specified list. Private lists will only be shown if the authenticated user owns the specified list.
10 | 
11 | .PARAMETER list_id
12 |     The numerical id of the list.
13 | 
14 | .PARAMETER slug
15 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
16 | 
17 | .PARAMETER owner_screen_name
18 |     The screen name of the user who owns the list being requested by a slug .
19 | 
20 | .PARAMETER owner_id
21 |     The user ID of the user who owns the list being requested by a slug .
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/get-lists-show
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$list_id,
31 |         [string]$slug,
32 |         [string]$owner_screen_name,
33 |         [string]$owner_id
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'GET'
41 |         [string]$Resource    = '/lists/show'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/show.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterLists_Subscriptions.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterLists_Subscriptions {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     GET lists/subscriptions
 8 |     
 9 |     Obtain a collection of the lists the specified user is subscribed to, 20 lists per page by default. Does not include the user's own lists.
10 | 
11 | .PARAMETER user_id
12 |     The ID of the user for whom to return results. Helpful for disambiguating when a valid user ID is also a valid screen name.
13 | 
14 | .PARAMETER screen_name
15 |     The screen name of the user for whom to return results. Helpful for disambiguating when a valid screen name is also a user ID.
16 | 
17 | .PARAMETER count
18 |     The amount of results to return per page. Defaults to 20. No more than 1000 results will ever be returned in a single page.
19 | 
20 | .PARAMETER cursor
21 |     Breaks the results into pages. Provide a value of -1 to begin paging. Provide values as returned in the response body's next_cursor and previous_cursor attributes to page back and forth in the list. It is recommended to always use cursors when the method supports them. See Cursoring for more information.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/get-lists-subscriptions
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$user_id,
31 |         [string]$screen_name,
32 |         [string]$count,
33 |         [string]$cursor
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'GET'
41 |         [string]$Resource    = '/lists/subscriptions'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/subscriptions.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterLists_list.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterLists_List {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     GET lists/list
 8 |     
 9 |     Returns all lists the authenticating or specified user subscribes to, including their own. The user is specified using the user_id or screen_name parameters. If no user is given, the authenticating user is used.
10 |     
11 |     A maximum of 100 results will be returned by this call. Subscribed lists are returned first, followed by owned lists. This means that if a user subscribes to 90 lists and owns 20 lists, this method returns 90 subscriptions and 10 owned lists. The reverse method returns owned lists first, so with reverse=true, 20 owned lists and 80 subscriptions would be returned. If your goal is to obtain every list a user owns or subscribes to, use GET lists / ownerships and/or GET lists / subscriptions instead.
12 | 
13 | .PARAMETER user_id
14 |     The ID of the user for whom to return results. Helpful for disambiguating when a valid user ID is also a valid screen name. Note: : Specifies the ID of the user to get lists from. Helpful for disambiguating when a valid user ID is also a valid screen name.
15 | 
16 | .PARAMETER screen_name
17 |     The screen name of the user for whom to return results. Helpful for disambiguating when a valid screen name is also a user ID.
18 | 
19 | .PARAMETER reverse
20 |     Set this to true if you would like owned lists to be returned first. See description above for information on how this parameter works.
21 | 
22 | .NOTES
23 |     This helper function was generated by the information provided here:
24 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/get-lists-list
25 | 
26 | #>
27 |     [CmdletBinding()]
28 |     Param(
29 |         [string]$user_id,
30 |         [string]$screen_name,
31 |         [string]$reverse
32 |     )
33 |     Begin {
34 | 
35 |         [hashtable]$Parameters = $PSBoundParameters
36 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
37 | 
38 |         [string]$Method      = 'GET'
39 |         [string]$Resource    = '/lists/list'
40 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/list.json'
41 | 
42 |     }
43 |     Process {
44 | 
45 |         # Find & Replace any ResourceUrl parameters.
46 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
47 |         ForEach ($UrlParameter in $UrlParameters) {
48 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
49 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
50 |         }
51 | 
52 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
53 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
54 | 
55 |     }
56 |     End {
57 | 
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterMutes_UsersIds.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterMutes_UsersIds {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     GET mutes/users/ids
 8 |     
 9 |     Returns an array of numeric user ids the authenticating user has muted.
10 | 
11 | .PARAMETER stringify_ids
12 |     Many programming environments will not consume Twitter IDs due to their size. Provide this option to have IDs returned as strings instead. Read more about Twitter IDs .
13 | 
14 | .PARAMETER cursor
15 |     Causes the list of IDs to be broken into pages of no more than 5000 IDs at a time. The number of IDs returned is not guaranteed to be 5000 as suspended users are filtered out. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
16 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth. See Using cursors to navigate collections for more information.
17 | 
18 | .NOTES
19 |     This helper function was generated by the information provided here:
20 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/get-mutes-users-ids
21 | 
22 | #>
23 |     [CmdletBinding()]
24 |     Param(
25 |         [string]$stringify_ids,
26 |         [string]$cursor
27 |     )
28 |     Begin {
29 | 
30 |         [hashtable]$Parameters = $PSBoundParameters
31 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
32 | 
33 |         [string]$Method      = 'GET'
34 |         [string]$Resource    = '/mutes/users/ids'
35 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/mutes/users/ids.json'
36 | 
37 |     }
38 |     Process {
39 | 
40 |         # Find & Replace any ResourceUrl parameters.
41 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
42 |         ForEach ($UrlParameter in $UrlParameters) {
43 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
44 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
45 |         }
46 | 
47 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
48 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
49 | 
50 |     }
51 |     End {
52 | 
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterMutes_UsersList.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterMutes_UsersList {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     GET mutes/users/list
 8 |     
 9 |     Returns an array of user objects the authenticating user has muted.
10 | 
11 | .PARAMETER cursor
12 |     Causes the list of IDs to be broken into pages of no more than 5000 IDs at a time. The number of IDs returned is not guaranteed to be 5000 as suspended users are filtered out. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
13 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth. See Using cursors to navigate collections for more information.
14 | 
15 | .PARAMETER include_entities
16 |     The entities node will not be included when set to false .
17 | 
18 | .PARAMETER skip_status
19 |     When set to either true , t or 1 statuses will not be included in the returned user objects.
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/get-mutes-users-list
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$cursor,
29 |         [string]$include_entities,
30 |         [string]$skip_status
31 |     )
32 |     Begin {
33 | 
34 |         [hashtable]$Parameters = $PSBoundParameters
35 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
36 | 
37 |         [string]$Method      = 'GET'
38 |         [string]$Resource    = '/mutes/users/list'
39 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/mutes/users/list.json'
40 | 
41 |     }
42 |     Process {
43 | 
44 |         # Find & Replace any ResourceUrl parameters.
45 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
46 |         ForEach ($UrlParameter in $UrlParameters) {
47 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
48 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
49 |         }
50 | 
51 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
52 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
53 | 
54 |     }
55 |     End {
56 | 
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterOauth_Authenticate.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterOauth_Authenticate {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     GET oauth/authenticate
 8 |     
 9 |     Allows a Consumer application to use an OAuth request_token to request user authorization.
10 |     
11 |     This method is a replacement of Section 6.2 of the OAuth 1.0 authentication flow for applications using the callback authentication flow. The method will use the currently logged in user as the account for access authorization unless the force_login parameter is set to true.
12 |     
13 |     This method differs from GET oauth / authorize in that if the user has already granted the application permission, the redirect will occur without the user having to re-approve the application. To realize this behavior, you must enable the Use Sign in with Twitter setting on your application record.
14 | 
15 | .PARAMETER force_login
16 |     Forces the user to enter their credentials to ensure the correct users account is authorized.
17 | 
18 | .PARAMETER screen_name
19 |     Prefills the username input box of the OAuth login screen with the given value.
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/authenticate
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$force_login,
29 |         [string]$screen_name
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'GET'
37 |         [string]$Resource    = '/oauth/authenticate'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth/authenticate'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterOauth_Authorize.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterOauth_Authorize {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     GET oauth/authorize
 8 |     
 9 |     Allows a Consumer application to use an OAuth Request Token to request user authorization. This method fulfills Section 6.2 of the OAuth 1.0 authentication flow. Desktop applications must use this method (and cannot use GET oauth / authenticate).
10 |     
11 |     Usage Note: An oauth_callback is never sent to this method, provide it to POST oauth / request_token instead.
12 | 
13 | .PARAMETER force_login
14 |     Forces the user to enter their credentials to ensure the correct users account is authorized.
15 | 
16 | .PARAMETER screen_name
17 |     Prefills the username input box of the OAuth login screen with the given value.
18 | 
19 | .NOTES
20 |     This helper function was generated by the information provided here:
21 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/authorize
22 | 
23 | #>
24 |     [CmdletBinding()]
25 |     Param(
26 |         [string]$force_login,
27 |         [string]$screen_name
28 |     )
29 |     Begin {
30 | 
31 |         [hashtable]$Parameters = $PSBoundParameters
32 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
33 | 
34 |         [string]$Method      = 'GET'
35 |         [string]$Resource    = '/oauth/authorize'
36 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth/authorize'
37 | 
38 |     }
39 |     Process {
40 | 
41 |         # Find & Replace any ResourceUrl parameters.
42 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
43 |         ForEach ($UrlParameter in $UrlParameters) {
44 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
45 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
46 |         }
47 | 
48 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
49 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
50 | 
51 |     }
52 |     End {
53 | 
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterSavedSearches_List.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterSavedSearches_List {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     GET saved_searches/list
 8 |     
 9 |     Returns the authenticated user's saved search queries.
10 | 
11 | 
12 | .NOTES
13 |     This helper function was generated by the information provided here:
14 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/get-saved_searches-list
15 | 
16 | #>
17 |     [CmdletBinding()]
18 |     Param(
19 |         
20 |     )
21 |     Begin {
22 | 
23 |         [hashtable]$Parameters = $PSBoundParameters
24 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
25 | 
26 |         [string]$Method      = 'GET'
27 |         [string]$Resource    = '/saved_searches/list'
28 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/saved_searches/list.json'
29 | 
30 |     }
31 |     Process {
32 | 
33 |         # Find & Replace any ResourceUrl parameters.
34 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
35 |         ForEach ($UrlParameter in $UrlParameters) {
36 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
37 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
38 |         }
39 | 
40 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
41 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
42 | 
43 |     }
44 |     End {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterSavedSearches_Show_Id.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterSavedSearches_Show_Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     GET saved_searches/show/:id
 8 |     
 9 |     Retrieve the information for the saved search represented by the given id. The authenticating user must be the owner of saved search ID being requested.
10 | 
11 | .PARAMETER id
12 |     The ID of the saved search.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/get-saved_searches-show-id
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/saved_searches/show/:id'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/saved_searches/show/:id.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterStatuses_RetweetersIds.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterStatuses_RetweetersIds {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET statuses/retweeters/ids
 8 |     
 9 |     Returns a collection of up to 100 user IDs belonging to users who have retweeted the Tweet specified by the id parameter.
10 |     
11 |     This method offers similar data to GET statuses / retweets / :id.
12 | 
13 | .PARAMETER id
14 |     The numerical ID of the desired status.
15 | 
16 | .PARAMETER count
17 |     Specifies the number of records to retrieve. Must be less than or equal to 100.
18 | 
19 | .PARAMETER cursor
20 |     Causes the list of IDs to be broken into pages of no more than 100 IDs at a time. The number of IDs returned is not guaranteed to be 100 as suspended users are filtered out after connections are queried. If no cursor is provided, a value of -1 will be assumed, which is the first "page."
21 | The response from the API will include a previous_cursor and next_cursor to allow paging back and forth. See our cursor docs for more information.
22 | While this method supports the cursor parameter, the entire result set can be returned in a single cursored collection. Using the count parameter with this method will not provide segmented cursors for use with this parameter.
23 | 
24 | .PARAMETER stringify_ids
25 |     Many programming environments will not consume Tweet ids due to their size. Provide this option to have ids returned as strings instead.
26 | 
27 | .NOTES
28 |     This helper function was generated by the information provided here:
29 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/get-statuses-retweeters-ids
30 | 
31 | #>
32 |     [CmdletBinding()]
33 |     Param(
34 |         [string]$id,
35 |         [string]$count,
36 |         [string]$cursor,
37 |         [string]$stringify_ids
38 |     )
39 |     Begin {
40 | 
41 |         [hashtable]$Parameters = $PSBoundParameters
42 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
43 | 
44 |         [string]$Method      = 'GET'
45 |         [string]$Resource    = '/statuses/retweeters/ids'
46 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/statuses/retweeters/ids.json'
47 | 
48 |     }
49 |     Process {
50 | 
51 |         # Find & Replace any ResourceUrl parameters.
52 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
53 |         ForEach ($UrlParameter in $UrlParameters) {
54 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
55 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
56 |         }
57 | 
58 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
59 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
60 | 
61 |     }
62 |     End {
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterStatuses_Retweets_Id.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterStatuses_Retweets_Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET statuses/retweets/:id
 8 |     
 9 |     Returns a collection of the 100 most recent retweets of the Tweet specified by the id parameter.
10 | 
11 | .PARAMETER id
12 |     The numerical ID of the desired status.
13 | 
14 | .PARAMETER count
15 |     Specifies the number of records to retrieve. Must be less than or equal to 100.
16 | 
17 | .PARAMETER trim_user
18 |     When set to either true , t or 1 , each tweet returned in a timeline will include a user object including only the status authors numerical ID. Omit this parameter to receive the complete user object.
19 | 
20 | .NOTES
21 |     This helper function was generated by the information provided here:
22 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/get-statuses-retweets-id
23 | 
24 | #>
25 |     [CmdletBinding()]
26 |     Param(
27 |         [string]$id,
28 |         [string]$count,
29 |         [string]$trim_user
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'GET'
37 |         [string]$Resource    = '/statuses/retweets/:id'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/statuses/retweets/:id.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterStatuses_Sample.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterStatuses_Sample {
 2 | <#
 3 | .SYNOPSIS
 4 |     Sample realtime Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     GET statuses/sample
 8 |     
 9 |     Returns a small random sample of all public statuses via a stream. The Tweets returned by the default access level are the same, so if two different clients connect to this endpoint, they will see the same Tweets.
10 | 
11 | .PARAMETER delimited
12 |     Specifies whether messages should be length-delimited. See delimited or more information.
13 | 
14 | .PARAMETER stall_warnings
15 |     Specifies whether stall warnings should be delivered. See stall_warnings for more information.
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/tweets/sample-realtime/api-reference/get-statuses-sample
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$delimited,
25 |         [string]$stall_warnings
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/statuses/sample'
34 |         [string]$ResourceUrl = 'https://stream.twitter.com/1.1/statuses/sample.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterTrends_Available.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterTrends_Available {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get locations with trending topics
 5 | 
 6 | .DESCRIPTION
 7 |     GET trends/available
 8 |     
 9 |     Returns the locations that Twitter has trending topic information for.
10 |     
11 |     The response is an array of "locations" that encode the location's WOEID and some other human-readable information such as a canonical name and country the location belongs in.
12 |     
13 |     A WOEID is a Yahoo! Where On Earth ID.
14 | 
15 | 
16 | .NOTES
17 |     This helper function was generated by the information provided here:
18 |     https://developer.twitter.com/en/docs/trends/locations-with-trending-topics/api-reference/get-trends-available
19 | 
20 | #>
21 |     [CmdletBinding()]
22 |     Param(
23 |         
24 |     )
25 |     Begin {
26 | 
27 |         [hashtable]$Parameters = $PSBoundParameters
28 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
29 | 
30 |         [string]$Method      = 'GET'
31 |         [string]$Resource    = '/trends/available'
32 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/trends/available.json'
33 | 
34 |     }
35 |     Process {
36 | 
37 |         # Find & Replace any ResourceUrl parameters.
38 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
39 |         ForEach ($UrlParameter in $UrlParameters) {
40 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
41 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
42 |         }
43 | 
44 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
45 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
46 | 
47 |     }
48 |     End {
49 | 
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterTrends_Closest.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterTrends_Closest {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get locations with trending topics
 5 | 
 6 | .DESCRIPTION
 7 |     GET trends/closest
 8 |     
 9 |     Returns the locations that Twitter has trending topic information for, closest to a specified location.
10 |     
11 |     The response is an array of "locations" that encode the location's WOEID and some other human-readable information such as a canonical name and country the location belongs in.
12 |     
13 |     A WOEID is a Yahoo! Where On Earth ID.
14 | 
15 | .PARAMETER lat
16 |     If provided with a long parameter the available trend locations will be sorted by distance, nearest to furthest, to the co-ordinate pair. The valid ranges for longitude is -180.0 to +180.0 (West is negative, East is positive) inclusive.
17 | 
18 | .PARAMETER long
19 |     If provided with a lat parameter the available trend locations will be sorted by distance, nearest to furthest, to the co-ordinate pair. The valid ranges for longitude is -180.0 to +180.0 (West is negative, East is positive) inclusive.
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/trends/locations-with-trending-topics/api-reference/get-trends-closest
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$lat,
29 |         [string]$long
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'GET'
37 |         [string]$Resource    = '/trends/closest'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/trends/closest.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterTrends_Place.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterTrends_Place {
 2 | <#
 3 | .SYNOPSIS
 4 |     Get trends near a location
 5 | 
 6 | .DESCRIPTION
 7 |     GET trends/place
 8 |     
 9 |     Returns the top 50 trending topics for a specific WOEID, if trending information is available for it.
10 |     
11 |     The response is an array of trend objects that encode the name of the trending topic, the query parameter that can be used to search for the topic on Twitter Search, and the Twitter Search URL.
12 |     
13 |     This information is cached for 5 minutes. Requesting more frequently than that will not return any more data, and will count against rate limit usage.
14 |     
15 |     The tweet_volume for the last 24 hours is also returned for many trends if this is available.
16 | 
17 | .PARAMETER id
18 |     The Yahoo! Where On Earth ID of the location to return trending information for. Global information is available by using 1 as the WOEID .
19 | 
20 | .PARAMETER exclude
21 |     Setting this equal to hashtags will remove all hashtags from the trends list.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/trends/trends-for-location/api-reference/get-trends-place
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$id,
31 |         [string]$exclude
32 |     )
33 |     Begin {
34 | 
35 |         [hashtable]$Parameters = $PSBoundParameters
36 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
37 | 
38 |         [string]$Method      = 'GET'
39 |         [string]$Resource    = '/trends/place'
40 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/trends/place.json'
41 | 
42 |     }
43 |     Process {
44 | 
45 |         # Find & Replace any ResourceUrl parameters.
46 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
47 |         ForEach ($UrlParameter in $UrlParameters) {
48 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
49 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
50 |         }
51 | 
52 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
53 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
54 | 
55 |     }
56 |     End {
57 | 
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterUsers_ProfileBanner.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterUsers_ProfileBanner {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     GET users/profile_banner
 8 |     
 9 |     Returns a map of the available size variations of the specified user's profile banner. If the user has not uploaded a profile banner, a HTTP 404 will be served instead. This method can be used instead of string manipulation on the profile_banner_url returned in user objects as described in Profile Images and Banners.
10 |     
11 |     The profile banner data available at each size variant's URL is in PNG format.
12 | 
13 | .PARAMETER user_id
14 |     The ID of the user for whom to return results. Helpful for disambiguating when a valid user ID is also a valid screen name.
15 | 
16 | .PARAMETER screen_name
17 |     The screen name of the user for whom to return results. Helpful for disambiguating when a valid screen name is also a user ID.
18 | 
19 | .NOTES
20 |     This helper function was generated by the information provided here:
21 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/get-users-profile_banner
22 | 
23 | #>
24 |     [CmdletBinding()]
25 |     Param(
26 |         [string]$user_id,
27 |         [string]$screen_name
28 |     )
29 |     Begin {
30 | 
31 |         [hashtable]$Parameters = $PSBoundParameters
32 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
33 | 
34 |         [string]$Method      = 'GET'
35 |         [string]$Resource    = '/users/profile_banner'
36 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/profile_banner.json'
37 | 
38 |     }
39 |     Process {
40 | 
41 |         # Find & Replace any ResourceUrl parameters.
42 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
43 |         ForEach ($UrlParameter in $UrlParameters) {
44 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
45 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
46 |         }
47 | 
48 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
49 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
50 | 
51 |     }
52 |     End {
53 | 
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterUsers_Search.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterUsers_Search {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET users/search
 8 |     
 9 |     Provides a simple, relevance-based search interface to public user accounts on Twitter. Try querying by topical interest, full name, company name, location, or other criteria. Exact match searches are not supported.
10 |     
11 |     Only the first 1,000 matching results are available.
12 | 
13 | .PARAMETER q
14 |     The search query to run against people search.
15 | 
16 | .PARAMETER page
17 |     Specifies the page of results to retrieve.
18 | 
19 | .PARAMETER count
20 |     The number of potential user results to retrieve per page. This value has a maximum of 20.
21 | 
22 | .PARAMETER include_entities
23 |     The entities node will not be included in embedded Tweet objects when set to false .
24 | 
25 | .NOTES
26 |     This helper function was generated by the information provided here:
27 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-search
28 | 
29 | #>
30 |     [CmdletBinding()]
31 |     Param(
32 |         [string]$q,
33 |         [string]$page,
34 |         [string]$count,
35 |         [string]$include_entities
36 |     )
37 |     Begin {
38 | 
39 |         [hashtable]$Parameters = $PSBoundParameters
40 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
41 | 
42 |         [string]$Method      = 'GET'
43 |         [string]$Resource    = '/users/search'
44 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/search.json'
45 | 
46 |     }
47 |     Process {
48 | 
49 |         # Find & Replace any ResourceUrl parameters.
50 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
51 |         ForEach ($UrlParameter in $UrlParameters) {
52 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
53 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
54 |         }
55 | 
56 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
57 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
58 | 
59 |     }
60 |     End {
61 | 
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterUsers_Show.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterUsers_Show {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET users/show
 8 |     
 9 |     Returns a variety of information about the user specified by the required user_id or screen_name parameter. The author's most recent Tweet will be returned inline when possible.
10 |     
11 |     GET users / lookup is used to retrieve a bulk collection of user objects.
12 |     
13 |     You must be following a protected user to be able to see their most recent Tweet. If you don't follow a protected user, the user's Tweet will be removed. A Tweet will not always be returned in the current_status field.
14 | 
15 | .PARAMETER user_id
16 |     The ID of the user for whom to return results. Either an id or screen_name is required for this method.
17 | 
18 | .PARAMETER screen_name
19 |     The screen name of the user for whom to return results. Either a id or screen_name is required for this method.
20 | 
21 | .PARAMETER include_entities
22 |     The entities node will not be included when set to false.
23 | 
24 | .NOTES
25 |     This helper function was generated by the information provided here:
26 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-show
27 | 
28 | #>
29 |     [CmdletBinding()]
30 |     Param(
31 |         [string]$user_id,
32 |         [string]$screen_name,
33 |         [string]$include_entities
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'GET'
41 |         [string]$Resource    = '/users/show'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/show.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterUsers_Suggestions.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterUsers_Suggestions {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     Access to Twitter's suggested user list. This returns the list of suggested user categories. The category can be used in GET users / suggestions / :slug to get the users in that category.
 8 | 
 9 | .PARAMETER lang
10 |     Restricts the suggested categories to the requested language. The language must be specified by the appropriate two letter ISO 639-1 representation. Currently supported languages are provided by the GET help/languages API request. Unsupported language codes will receive English (en) results. If you use lang in this request, ensure you also include it when requesting the GET users/suggestions/:slug list.
11 | 
12 | .NOTES
13 |     This helper function was generated by the information provided here:
14 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-suggestions
15 | 
16 | #>
17 |     [CmdletBinding()]
18 |     Param(
19 |         [string]$lang
20 |     )
21 |     Begin {
22 | 
23 |         [hashtable]$Parameters = $PSBoundParameters
24 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
25 | 
26 |         [string]$Method      = 'GET'
27 |         [string]$Resource    = '/users/suggestions'
28 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/suggestions.json'
29 | 
30 |     }
31 |     Process {
32 | 
33 |         # Find & Replace any ResourceUrl parameters.
34 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
35 |         ForEach ($UrlParameter in $UrlParameters) {
36 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
37 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
38 |         }
39 | 
40 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
41 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
42 | 
43 |     }
44 |     End {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterUsers_Suggestions_Slug.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterUsers_Suggestions_Slug {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     Access the users in a given category of the Twitter suggested user list.
 8 |     
 9 |     It is recommended that applications cache this data for no more than one hour.
10 | 
11 | .PARAMETER slug
12 |     The short name of list or a category
13 | 
14 | .PARAMETER lang
15 |     Restricts the suggested categories to the requested language. The language must be specified by the appropriate two letter ISO 639-1 representation. Currently supported languages are provided by the GET help/languages API request. Unsupported language codes will receive English (en) results. If you use lang in this request, ensure you also include it when requesting the GET users/suggestions/:slug list.
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-suggestions-slug
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$slug,
25 |         [string]$lang
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'GET'
33 |         [string]$Resource    = '/users/suggestions/:slug'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/suggestions/:slug.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Get-TwitterUsers_Suggestions_SlugMembers.ps1:
--------------------------------------------------------------------------------
 1 | function Get-TwitterUsers_Suggestions_SlugMembers {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     GET users/suggestions/:slug/members
 8 |     
 9 |     Access the users in a given category of the Twitter suggested user list and return their most recent status if they are not a protected user.
10 | 
11 | .PARAMETER slug
12 |     The short name of list or a category
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-suggestions-slug-members
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$slug
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'GET'
29 |         [string]$Resource    = '/users/suggestions/:slug/members'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/suggestions/:slug/members.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Remove-TwitterCustomProfiles_Destroy.ps1:
--------------------------------------------------------------------------------
 1 | function Remove-TwitterCustomProfiles_Destroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Custom profiles
 5 | 
 6 | .DESCRIPTION
 7 |     DELETE custom_profiles/destroy.json
 8 |     
 9 |     Deletes a custom profile that was created with POST custom_profiles/new.json.
10 | 
11 | .PARAMETER id (required)
12 |     
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/direct-messages/custom-profiles/api-reference/delete-profile
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'DELETE'
29 |         [string]$Resource    = '/custom_profiles/destroy'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/custom_profiles/destroy.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterAccount_RemoveProfileBanner.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterAccount_RemoveProfileBanner {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     POST account/remove_profile_banner
 8 |     
 9 |     Removes the uploaded profile banner for the authenticating user. Returns HTTP 200 upon success.
10 | 
11 | 
12 | .NOTES
13 |     This helper function was generated by the information provided here:
14 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/post-account-remove_profile_banner
15 | 
16 | #>
17 |     [CmdletBinding()]
18 |     Param(
19 |         
20 |     )
21 |     Begin {
22 | 
23 |         [hashtable]$Parameters = $PSBoundParameters
24 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
25 | 
26 |         [string]$Method      = 'POST'
27 |         [string]$Resource    = '/account/remove_profile_banner'
28 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/account/remove_profile_banner.json'
29 | 
30 |     }
31 |     Process {
32 | 
33 |         # Find & Replace any ResourceUrl parameters.
34 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
35 |         ForEach ($UrlParameter in $UrlParameters) {
36 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
37 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
38 |         }
39 | 
40 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
41 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
42 | 
43 |     }
44 |     End {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterAccount_UpdateProfile.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterAccount_UpdateProfile {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     POST account/update_profile
 8 |     
 9 |     Sets some values that users are able to set under the "Account" tab of their settings page. Only the parameters specified will be updated.
10 | 
11 | .PARAMETER url
12 |     URL associated with the profile. Will be prepended with http:// if not present.
13 | 
14 | .PARAMETER location
15 |     The city or country describing where the user of the account is located. The contents are not normalized or geocoded in any way.
16 | 
17 | .PARAMETER description
18 |     A description of the user owning the account.
19 | 
20 | .PARAMETER profile_link_color
21 |     Sets a hex value that controls the color scheme of links used on the authenticating user's profile page on twitter.com. This must be a valid hexadecimal value, and may be either three or six characters (ex: F00 or FF0000). This parameter replaces the deprecated (and separate) update_profile_colors API method.
22 | 
23 | .PARAMETER include_entities
24 |     The entities node will not be included when set to false .
25 | 
26 | .PARAMETER skip_status
27 |     When set to either true , t or 1 statuses will not be included in the returned user object.
28 | 
29 | .NOTES
30 |     This helper function was generated by the information provided here:
31 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/post-account-update_profile
32 | 
33 | #>
34 |     [CmdletBinding()]
35 |     Param(
36 |         [string]$url,
37 |         [string]$location,
38 |         [string]$description,
39 |         [string]$profile_link_color,
40 |         [string]$include_entities,
41 |         [string]$skip_status
42 |     )
43 |     Begin {
44 | 
45 |         [hashtable]$Parameters = $PSBoundParameters
46 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
47 | 
48 |         [string]$Method      = 'POST'
49 |         [string]$Resource    = '/account/update_profile'
50 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/account/update_profile.json'
51 | 
52 |     }
53 |     Process {
54 | 
55 |         # Find & Replace any ResourceUrl parameters.
56 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
57 |         ForEach ($UrlParameter in $UrlParameters) {
58 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
59 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
60 |         }
61 | 
62 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
63 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
64 | 
65 |     }
66 |     End {
67 | 
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterAccount_UpdateProfileImage.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterAccount_UpdateProfileImage {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     POST account/update_profile_image
 8 |     
 9 |     Updates the authenticating user's profile image. Note that this method expects raw multipart data, not a URL to an image.
10 |     
11 |     This method asynchronously processes the uploaded file before updating the user's profile image URL. You can either update your local cache the next time you request the user's information, or, at least 5 seconds after uploading the image, ask for the updated URL using GET users / show.
12 | 
13 | .PARAMETER image
14 |     The avatar image for the profile, base64-encoded. Must be a valid GIF, JPG, or PNG image of less than 700 kilobytes in size. Images with width larger than 400 pixels will be scaled down. Animated GIFs will be converted to a static GIF of the first frame, removing the animation.
15 | 
16 | .PARAMETER include_entities
17 |     The entities node will not be included when set to false .
18 | 
19 | .PARAMETER skip_status
20 |     When set to either true , t or 1 statuses will not be included in the returned user objects.
21 | 
22 | .NOTES
23 |     This helper function was generated by the information provided here:
24 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/post-account-update_profile_image
25 | 
26 | #>
27 |     [CmdletBinding()]
28 |     Param(
29 |         [string]$image,
30 |         [string]$include_entities,
31 |         [string]$skip_status
32 |     )
33 |     Begin {
34 | 
35 |         [hashtable]$Parameters = $PSBoundParameters
36 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
37 | 
38 |         [string]$Method      = 'POST'
39 |         [string]$Resource    = '/account/update_profile_image'
40 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/account/update_profile_image.json'
41 | 
42 |     }
43 |     Process {
44 | 
45 |         # Find & Replace any ResourceUrl parameters.
46 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
47 |         ForEach ($UrlParameter in $UrlParameters) {
48 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
49 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
50 |         }
51 | 
52 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
53 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
54 | 
55 |     }
56 |     End {
57 | 
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterBlocks_Create.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterBlocks_Create {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     POST blocks/create
 8 |     
 9 |     Blocks the specified user from following the authenticating user. In addition the blocked user will not show in the authenticating users mentions or timeline (unless retweeted by another user). If a follow or friend relationship exists it is destroyed.
10 |     
11 |     The URL pattern /version/block/create/:screen_name_or_user_id.format is still accepted but not recommended. As a sequence of numbers is a valid screen name we recommend using the screen_name or user_id parameter instead.
12 | 
13 | .PARAMETER screen_name
14 |     The screen name of the potentially blocked user. Helpful for disambiguating when a valid screen name is also a user ID.
15 | 
16 | .PARAMETER user_id
17 |     The ID of the potentially blocked user. Helpful for disambiguating when a valid user ID is also a valid screen name.
18 | 
19 | .PARAMETER include_entities
20 |     The entities node will not be included when set to false .
21 | 
22 | .PARAMETER skip_status
23 |     When set to either true , t or 1 statuses will not be included in the returned user objects.
24 | 
25 | .NOTES
26 |     This helper function was generated by the information provided here:
27 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/post-blocks-create
28 | 
29 | #>
30 |     [CmdletBinding()]
31 |     Param(
32 |         [string]$screen_name,
33 |         [string]$user_id,
34 |         [string]$include_entities,
35 |         [string]$skip_status
36 |     )
37 |     Begin {
38 | 
39 |         [hashtable]$Parameters = $PSBoundParameters
40 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
41 | 
42 |         [string]$Method      = 'POST'
43 |         [string]$Resource    = '/blocks/create'
44 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/blocks/create.json'
45 | 
46 |     }
47 |     Process {
48 | 
49 |         # Find & Replace any ResourceUrl parameters.
50 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
51 |         ForEach ($UrlParameter in $UrlParameters) {
52 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
53 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
54 |         }
55 | 
56 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
57 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
58 | 
59 |     }
60 |     End {
61 | 
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterBlocks_Destroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterBlocks_Destroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     POST blocks/destroy
 8 |     
 9 |     Un-blocks the user specified in the ID parameter for the authenticating user. Returns the un-blocked user when successful. If relationships existed before the block was instantiated, they will not be restored.
10 | 
11 | .PARAMETER screen_name
12 |     The screen name of the potentially blocked user. Helpful for disambiguating when a valid screen name is also a user ID.
13 | 
14 | .PARAMETER user_id
15 |     The ID of the potentially blocked user. Helpful for disambiguating when a valid user ID is also a valid screen name.
16 | 
17 | .PARAMETER include_entities
18 |     The entities node will not be included when set to false .
19 | 
20 | .PARAMETER skip_status
21 |     When set to either true , t or 1 statuses will not be included in the returned user objects.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/post-blocks-destroy
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$screen_name,
31 |         [string]$user_id,
32 |         [string]$include_entities,
33 |         [string]$skip_status
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/blocks/destroy'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/blocks/destroy.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_Create.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_Create {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/create
 8 |     
 9 |     Create a Collection owned by the currently authenticated user.
10 |     
11 |     The API endpoint may refuse to complete the request if the authenticated user has exceeded the total number of allowed collections for their account.
12 | 
13 | .PARAMETER description
14 |     A brief description of this collection in 160 characters or fewer.
15 | 
16 | .PARAMETER url
17 |     A fully-qualified URL to associate with this collection.
18 | 
19 | .PARAMETER timeline_order
20 |     Order Tweets chronologically or in the order they are added to a Collection. curation_reverse_chron - order added (default) tweet_chron - oldest first tweet_reverse_chron - most recent first
21 | 
22 | .NOTES
23 |     This helper function was generated by the information provided here:
24 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-create
25 | 
26 | #>
27 |     [CmdletBinding()]
28 |     Param(
29 |         [string]$description,
30 |         [string]$url,
31 |         [string]$timeline_order
32 |     )
33 |     Begin {
34 | 
35 |         [hashtable]$Parameters = $PSBoundParameters
36 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
37 | 
38 |         [string]$Method      = 'POST'
39 |         [string]$Resource    = '/collections/create'
40 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/create.json'
41 | 
42 |     }
43 |     Process {
44 | 
45 |         # Find & Replace any ResourceUrl parameters.
46 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
47 |         ForEach ($UrlParameter in $UrlParameters) {
48 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
49 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
50 |         }
51 | 
52 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
53 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
54 | 
55 |     }
56 |     End {
57 | 
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_Destroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_Destroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/destroy
 8 |     
 9 |     Permanently delete a Collection owned by the currently authenticated user.
10 | 
11 | .PARAMETER id
12 |     The identifier of the Collection to destroy.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-destroy
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'POST'
29 |         [string]$Resource    = '/collections/destroy'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/destroy.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_EntriesAdd.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_EntriesAdd {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/entries/add
 8 |     
 9 |     Add a specified Tweet to a Collection.
10 |     
11 |     A collection will store up to a few thousand Tweets. Adding a Tweet to a collection beyond its allowed capacity will remove the oldest Tweet in the collection based on the time it was added to the collection.
12 |     
13 |     Use POST collections / entries / curate to add Tweets to a Collection in bulk.
14 | 
15 | .PARAMETER id
16 |     The identifier of the Collection receiving the Tweet.
17 | 
18 | .PARAMETER tweet_id
19 |     The identifier of the Tweet to add to the Collection.
20 | 
21 | .PARAMETER relative_to
22 |     The identifier of the Tweet used for relative positioning in a curation_reverse_chron ordered collection.
23 | 
24 | .PARAMETER above
25 |     Set to false to insert the specified tweet_id below the relative_to Tweet in the collection. Default: true
26 | 
27 | .NOTES
28 |     This helper function was generated by the information provided here:
29 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-entries-add
30 | 
31 | #>
32 |     [CmdletBinding()]
33 |     Param(
34 |         [string]$id,
35 |         [string]$tweet_id,
36 |         [string]$relative_to,
37 |         [string]$above
38 |     )
39 |     Begin {
40 | 
41 |         [hashtable]$Parameters = $PSBoundParameters
42 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
43 | 
44 |         [string]$Method      = 'POST'
45 |         [string]$Resource    = '/collections/entries/add'
46 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/entries/add.json'
47 | 
48 |     }
49 |     Process {
50 | 
51 |         # Find & Replace any ResourceUrl parameters.
52 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
53 |         ForEach ($UrlParameter in $UrlParameters) {
54 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
55 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
56 |         }
57 | 
58 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
59 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
60 | 
61 |     }
62 |     End {
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_EntriesCurate.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_EntriesCurate {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/entries/curate
 8 |     
 9 |     Curate a Collection by adding or removing Tweets in bulk. Updates must be limited to 100 cumulative additions or removals per request.
10 |     
11 |     Use POST collections / entries / add and POST collections / entries / remove to add or remove a single Tweet.
12 | 
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-entries-curate
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'POST'
29 |         [string]$Resource    = '/collections/entries/curate'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/entries/curate.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_EntriesMove.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_EntriesMove {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/entries/move
 8 |     
 9 |     Move a specified Tweet to a new position in a curation_reverse_chron ordered collection.
10 | 
11 | .PARAMETER id
12 |     The identifier of the Collection receiving the Tweet.
13 | 
14 | .PARAMETER tweet_id
15 |     The identifier of the Tweet to add to the Collection.
16 | 
17 | .PARAMETER relative_to
18 |     The identifier of the Tweet used for relative positioning.
19 | 
20 | .PARAMETER above
21 |     Set to false to insert the specified tweet_id below the relative_to Tweet in the collection. Default: true
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-entries-move
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$id,
31 |         [string]$tweet_id,
32 |         [string]$relative_to,
33 |         [string]$above
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/collections/entries/move'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/entries/move.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_EntriesRemove.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_EntriesRemove {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/entries/remove
 8 |     
 9 |     Remove the specified Tweet from a Collection.
10 |     
11 |     Use POST collections / entries / curate to remove Tweets from a Collection in bulk.
12 | 
13 | .PARAMETER id
14 |     The identifier of the target Collection.
15 | 
16 | .PARAMETER tweet_id
17 |     The identifier of the Tweet to remove.
18 | 
19 | .NOTES
20 |     This helper function was generated by the information provided here:
21 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-entries-remove
22 | 
23 | #>
24 |     [CmdletBinding()]
25 |     Param(
26 |         [string]$id,
27 |         [string]$tweet_id
28 |     )
29 |     Begin {
30 | 
31 |         [hashtable]$Parameters = $PSBoundParameters
32 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
33 | 
34 |         [string]$Method      = 'POST'
35 |         [string]$Resource    = '/collections/entries/remove'
36 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/entries/remove.json'
37 | 
38 |     }
39 |     Process {
40 | 
41 |         # Find & Replace any ResourceUrl parameters.
42 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
43 |         ForEach ($UrlParameter in $UrlParameters) {
44 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
45 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
46 |         }
47 | 
48 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
49 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
50 | 
51 |     }
52 |     End {
53 | 
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCollections_Update.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCollections_Update {
 2 | <#
 3 | .SYNOPSIS
 4 |     Curate a collection of Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST collections/update
 8 |     
 9 |     Update information concerning a Collection owned by the currently authenticated user.
10 |     
11 |     Partial updates are not currently supported: please provide name, description, and url whenever using this method. Omitted description or url parameters will be treated as if an empty string was passed, overwriting any previously stored value for the Collection.
12 | 
13 | .PARAMETER id
14 |     The identifier of the Collection to modify.
15 | 
16 | .PARAMETER description
17 |     A brief description of this Collection in 160 characters or fewer.
18 | 
19 | .PARAMETER url
20 |     A fully-qualified URL to associate with this Collection.
21 | 
22 | .NOTES
23 |     This helper function was generated by the information provided here:
24 |     https://developer.twitter.com/en/docs/tweets/curate-a-collection/api-reference/post-collections-update
25 | 
26 | #>
27 |     [CmdletBinding()]
28 |     Param(
29 |         [string]$id,
30 |         [string]$description,
31 |         [string]$url
32 |     )
33 |     Begin {
34 | 
35 |         [hashtable]$Parameters = $PSBoundParameters
36 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
37 | 
38 |         [string]$Method      = 'POST'
39 |         [string]$Resource    = '/collections/update'
40 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/collections/update.json'
41 | 
42 |     }
43 |     Process {
44 | 
45 |         # Find & Replace any ResourceUrl parameters.
46 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
47 |         ForEach ($UrlParameter in $UrlParameters) {
48 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
49 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
50 |         }
51 | 
52 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
53 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
54 | 
55 |     }
56 |     End {
57 | 
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterCustomProfiles_New.Json.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterCustomProfiles_New.Json {
 2 | <#
 3 | .SYNOPSIS
 4 |     Custom profiles
 5 | 
 6 | .DESCRIPTION
 7 |     POST custom_profiles/new.json
 8 |     
 9 |     Creates a new custom profile. The returned ID should be used with when publishing a new message with POST direct_messages/events/new.
10 | 
11 | .PARAMETER name (required)
12 |     
13 | 
14 | .PARAMETER avatar.media.id (required)
15 |     
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/direct-messages/custom-profiles/api-reference/new-profile
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$name,
25 |         [string]$avatar
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'POST'
33 |         [string]$Resource    = '/custom_profiles/new.json'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/custom_profiles/new.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterDirectMessages_IndicateTyping.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterDirectMessages_IndicateTyping {
 2 | <#
 3 | .SYNOPSIS
 4 |     Typing indicator and read receipts
 5 | 
 6 | .DESCRIPTION
 7 |     POST direct_messages/indicate_typing
 8 |     
 9 |     Displays a visual typing indicator in the recipient’s Direct Message conversation view with the sender. Each request triggers a typing indicator animation with a duration of ~3 seconds.
10 |     
11 |     Usage
12 |     
13 |     A rudimentary approach would be to invoke an API request on every keypress or input event, however the application may quickly hit rate limits. A more sophisticated approach is to capture input events, but limit API requests to a specified interval based on the behavior of your users and the rate limit specified below.
14 | 
15 | .PARAMETER recipient_id (required)
16 |     
17 | 
18 | .PARAMETER 204
19 |     
20 | 
21 | .PARAMETER 400
22 |     
23 | 
24 | .NOTES
25 |     This helper function was generated by the information provided here:
26 |     https://developer.twitter.com/en/docs/direct-messages/typing-indicator-and-read-receipts/api-reference/new-typing-indicator
27 | 
28 | #>
29 |     [CmdletBinding()]
30 |     Param(
31 |         [string]$recipient_id,
32 |         [string]$204,
33 |         [string]$400
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/direct_messages/indicate_typing'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/indicate_typing.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterDirectMessages_MarkRead.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterDirectMessages_MarkRead {
 2 | <#
 3 | .SYNOPSIS
 4 |     Typing indicator and read receipts
 5 | 
 6 | .DESCRIPTION
 7 |     POST direct_messages/mark_read
 8 |     
 9 |     Marks a message as read in the recipient’s Direct Message conversation view with the sender.
10 | 
11 | .PARAMETER last_read_event_id (required)
12 |     
13 | 
14 | .PARAMETER recipient_id (required)
15 |     
16 | 
17 | .PARAMETER 204
18 |     
19 | 
20 | .PARAMETER 400
21 |     
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/direct-messages/typing-indicator-and-read-receipts/api-reference/new-read-receipt
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$last_read_event_id,
31 |         [string]$recipient_id,
32 |         [string]$204,
33 |         [string]$400
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/direct_messages/mark_read'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/mark_read.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterDirectMessages_WelcomeMessagesNew.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterDirectMessages_WelcomeMessagesNew {
 2 | <#
 3 | .SYNOPSIS
 4 |     Welcome Messages
 5 | 
 6 | .DESCRIPTION
 7 |     POST direct_messages/welcome_messages/new
 8 |     
 9 |     Creates a new Welcome Message that will be stored and sent in the future from the authenticating user in defined circumstances. Returns the message template if successful. Supports publishing with the same elements as Direct Messages (e.g. Quick Replies, media attachments).
10 |     
11 |     Requires a JSON POST body and Content-Type header to be set to application/json. Setting Content-Length may also be required if it is not automatically.
12 |     
13 |     See the Welcome Messages overview to learn how to work with Welcome Messages.
14 | 
15 | 
16 | .NOTES
17 |     This helper function was generated by the information provided here:
18 |     https://developer.twitter.com/en/docs/direct-messages/welcome-messages/api-reference/new-welcome-message
19 | 
20 | #>
21 |     [CmdletBinding()]
22 |     Param(
23 |         
24 |     )
25 |     Begin {
26 | 
27 |         [hashtable]$Parameters = $PSBoundParameters
28 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
29 | 
30 |         [string]$Method      = 'POST'
31 |         [string]$Resource    = '/direct_messages/welcome_messages/new'
32 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/welcome_messages/new.json'
33 | 
34 |     }
35 |     Process {
36 | 
37 |         # Find & Replace any ResourceUrl parameters.
38 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
39 |         ForEach ($UrlParameter in $UrlParameters) {
40 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
41 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
42 |         }
43 | 
44 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
45 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
46 | 
47 |     }
48 |     End {
49 | 
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterDirectMessages_WelcomeMessagesRulesNew.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterDirectMessages_WelcomeMessagesRulesNew {
 2 | <#
 3 | .SYNOPSIS
 4 |     Welcome Messages
 5 | 
 6 | .DESCRIPTION
 7 |     POST direct_messages/welcome_messages/rules/new
 8 |     
 9 |     Creates a new Welcome Message Rule that determines which Welcome Message will be shown in a given conversation. Returns the created rule if successful.
10 |     
11 |     Requires a JSON POST body and Content-Type header to be set to application/json. Setting Content-Length may also be required if it is not automatically.
12 |     
13 |     Additional rule configurations are forthcoming. For the initial beta release, the most recently created Rule will always take precedence, and the assigned Welcome Message will be displayed in the conversation.
14 |     
15 |     See the Welcome Messages overview to learn how to work with Welcome Messages.
16 | 
17 | 
18 | .NOTES
19 |     This helper function was generated by the information provided here:
20 |     https://developer.twitter.com/en/docs/direct-messages/welcome-messages/api-reference/new-welcome-message-rule
21 | 
22 | #>
23 |     [CmdletBinding()]
24 |     Param(
25 |         
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'POST'
33 |         [string]$Resource    = '/direct_messages/welcome_messages/rules/new'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/direct_messages/welcome_messages/rules/new.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterFavorites_Create.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterFavorites_Create {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST favorites/create
 8 |     
 9 |     Note: favorites are now known as likes.
10 |     
11 |     Favorites (likes) the Tweet specified in the ID parameter as the authenticating user. Returns the favorite Tweet when successful.
12 |     
13 |     The process invoked by this method is asynchronous. The immediately returned Tweet object may not indicate the resultant favorited status of the Tweet. A 200 OK response from this method will indicate whether the intended action was successful or not.
14 | 
15 | .PARAMETER id
16 |     The numerical ID of the Tweet to like.
17 | 
18 | .PARAMETER include_entities
19 |     The entities node will be omitted when set to false .
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-favorites-create
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$id,
29 |         [string]$include_entities
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/favorites/create'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/favorites/create.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterFavorites_Destroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterFavorites_Destroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST favorites/destroy
 8 |     
 9 |     Note: favorites are now known as likes.
10 |     
11 |     Unfavorites (un-likes) the Tweet specified in the ID parameter as the authenticating user. Returns the un-liked Tweet when successful.
12 |     
13 |     The process invoked by this method is asynchronous. The immediately returned Tweet object may not indicate the resultant favorited status of the Tweet. A 200 OK response from this method will indicate whether the intended action was successful or not.
14 | 
15 | .PARAMETER id
16 |     The numerical ID of the Tweet to un-like
17 | 
18 | .PARAMETER include_entities
19 |     The entities node will be omitted when set to false .
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-favorites-destroy
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$id,
29 |         [string]$include_entities
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/favorites/destroy'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/favorites/destroy.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterFriendships_Create.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterFriendships_Create {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     POST friendships/create
 8 |     
 9 |     Allows the authenticating user to follow (friend) the user specified in the ID parameter.
10 |     
11 |     Returns the followed user when successful. Returns a string describing the failure condition when unsuccessful. If the user is already friends with the user a HTTP 403 may be returned, though for performance reasons this method may also return a HTTP 200 OK message even if the follow relationship already exists.
12 |     
13 |     Actions taken in this method are asynchronous. Changes will be eventually consistent.
14 | 
15 | .PARAMETER screen_name
16 |     The screen name of the user to follow.
17 | 
18 | .PARAMETER user_id
19 |     The ID of the user to follow.
20 | 
21 | .PARAMETER follow
22 |     Enable notifications for the target user.
23 | 
24 | .NOTES
25 |     This helper function was generated by the information provided here:
26 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/post-friendships-create
27 | 
28 | #>
29 |     [CmdletBinding()]
30 |     Param(
31 |         [string]$screen_name,
32 |         [string]$user_id,
33 |         [string]$follow
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/friendships/create'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/create.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterFriendships_Destroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterFriendships_Destroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     POST friendships/destroy
 8 |     
 9 |     Allows the authenticating user to unfollow the user specified in the ID parameter.
10 |     
11 |     Returns the unfollowed user when successful. Returns a string describing the failure condition when unsuccessful.
12 |     
13 |     Actions taken in this method are asynchronous. Changes will be eventually consistent.
14 | 
15 | .PARAMETER screen_name
16 |     The screen name of the user to unfollow.
17 | 
18 | .PARAMETER user_id
19 |     The ID of the user to unfollow.
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/post-friendships-destroy
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$screen_name,
29 |         [string]$user_id
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/friendships/destroy'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/destroy.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterFriendships_Update.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterFriendships_Update {
 2 | <#
 3 | .SYNOPSIS
 4 |     Follow, search, and get users
 5 | 
 6 | .DESCRIPTION
 7 |     POST friendships/update
 8 |     
 9 |     Enable or disable Retweets and device notifications from the specified user.
10 | 
11 | .PARAMETER screen_name
12 |     The screen name of the user being followed.
13 | 
14 | .PARAMETER user_id
15 |     The ID of the user being followed.
16 | 
17 | .PARAMETER device
18 |     Enable/disable device notifications from the target user.
19 | 
20 | .PARAMETER retweets
21 |     Enable/disable Retweets from the target user.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/post-friendships-update
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$screen_name,
31 |         [string]$user_id,
32 |         [string]$device,
33 |         [string]$retweets
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/friendships/update'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/friendships/update.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_Create.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_Create {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/create
 8 |     
 9 |     Creates a new list for the authenticated user. Note that you can create up to 1000 lists per account.
10 | 
11 | .PARAMETER mode
12 |     Whether your list is public or private. Values can be public or private . If no mode is specified the list will be public.
13 | 
14 | .PARAMETER description
15 |     The description to give the list.
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-create
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$mode,
25 |         [string]$description
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'POST'
33 |         [string]$Resource    = '/lists/create'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/create.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_Destroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_Destroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/destroy
 8 |     
 9 |     Deletes the specified list. The authenticated user must own the list to be able to destroy it.
10 | 
11 | .PARAMETER owner_screen_name
12 |     The screen name of the user who owns the list being requested by a slug .
13 | 
14 | .PARAMETER owner_id
15 |     The user ID of the user who owns the list being requested by a slug .
16 | 
17 | .PARAMETER list_id
18 |     The numerical id of the list.
19 | 
20 | .PARAMETER slug
21 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-destroy
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$owner_screen_name,
31 |         [string]$owner_id,
32 |         [string]$list_id,
33 |         [string]$slug
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/lists/destroy'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/destroy.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_MembersCreate.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_MembersCreate {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/members/create
 8 |     
 9 |     Add a member to a list. The authenticated user must own the list to be able to add members to it. Note that lists cannot have more than 5,000 members.
10 | 
11 | .PARAMETER list_id
12 |     The numerical id of the list.
13 | 
14 | .PARAMETER slug
15 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
16 | 
17 | .PARAMETER user_id
18 |     The ID of the user for whom to return results. Helpful for disambiguating when a valid user ID is also a valid screen name.
19 | 
20 | .PARAMETER screen_name
21 |     The screen name of the user for whom to return results. Helpful for disambiguating when a valid screen name is also a user ID.
22 | 
23 | .PARAMETER owner_screen_name
24 |     The screen name of the user who owns the list being requested by a slug.
25 | 
26 | .PARAMETER owner_id
27 |     The user ID of the user who owns the list being requested by a slug.
28 | 
29 | .NOTES
30 |     This helper function was generated by the information provided here:
31 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-members-create
32 | 
33 | #>
34 |     [CmdletBinding()]
35 |     Param(
36 |         [string]$list_id,
37 |         [string]$slug,
38 |         [string]$user_id,
39 |         [string]$screen_name,
40 |         [string]$owner_screen_name,
41 |         [string]$owner_id
42 |     )
43 |     Begin {
44 | 
45 |         [hashtable]$Parameters = $PSBoundParameters
46 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
47 | 
48 |         [string]$Method      = 'POST'
49 |         [string]$Resource    = '/lists/members/create'
50 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/members/create.json'
51 | 
52 |     }
53 |     Process {
54 | 
55 |         # Find & Replace any ResourceUrl parameters.
56 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
57 |         ForEach ($UrlParameter in $UrlParameters) {
58 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
59 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
60 |         }
61 | 
62 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
63 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
64 | 
65 |     }
66 |     End {
67 | 
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_MembersDestroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_MembersDestroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/members/destroy
 8 |     
 9 |     Removes the specified member from the list. The authenticated user must be the list's owner to remove members from the list.
10 | 
11 | .PARAMETER list_id
12 |     The numerical id of the list.
13 | 
14 | .PARAMETER slug
15 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
16 | 
17 | .PARAMETER user_id
18 |     The ID of the user to remove from the list. Helpful for disambiguating when a valid user ID is also a valid screen name.
19 | 
20 | .PARAMETER screen_name
21 |     The screen name of the user for whom to remove from the list. Helpful for disambiguating when a valid screen name is also a user ID.
22 | 
23 | .PARAMETER owner_screen_name
24 |     The screen name of the user who owns the list being requested by a slug .
25 | 
26 | .PARAMETER owner_id
27 |     The user ID of the user who owns the list being requested by a slug .
28 | 
29 | .NOTES
30 |     This helper function was generated by the information provided here:
31 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-members-destroy
32 | 
33 | #>
34 |     [CmdletBinding()]
35 |     Param(
36 |         [string]$list_id,
37 |         [string]$slug,
38 |         [string]$user_id,
39 |         [string]$screen_name,
40 |         [string]$owner_screen_name,
41 |         [string]$owner_id
42 |     )
43 |     Begin {
44 | 
45 |         [hashtable]$Parameters = $PSBoundParameters
46 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
47 | 
48 |         [string]$Method      = 'POST'
49 |         [string]$Resource    = '/lists/members/destroy'
50 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/members/destroy.json'
51 | 
52 |     }
53 |     Process {
54 | 
55 |         # Find & Replace any ResourceUrl parameters.
56 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
57 |         ForEach ($UrlParameter in $UrlParameters) {
58 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
59 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
60 |         }
61 | 
62 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
63 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
64 | 
65 |     }
66 |     End {
67 | 
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_SubscribersCreate.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_SubscribersCreate {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/subscribers/create
 8 |     
 9 |     Subscribes the authenticated user to the specified list.
10 | 
11 | .PARAMETER owner_screen_name
12 |     The screen name of the user who owns the list being requested by a slug .
13 | 
14 | .PARAMETER owner_id
15 |     The user ID of the user who owns the list being requested by a slug .
16 | 
17 | .PARAMETER list_id
18 |     The numerical id of the list.
19 | 
20 | .PARAMETER slug
21 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-subscribers-create
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$owner_screen_name,
31 |         [string]$owner_id,
32 |         [string]$list_id,
33 |         [string]$slug
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/lists/subscribers/create'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/subscribers/create.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_SubscribersDestroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_SubscribersDestroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/subscribers/destroy
 8 |     
 9 |     Unsubscribes the authenticated user from the specified list.
10 | 
11 | .PARAMETER list_id
12 |     The numerical id of the list.
13 | 
14 | .PARAMETER slug
15 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
16 | 
17 | .PARAMETER owner_screen_name
18 |     The screen name of the user who owns the list being requested by a slug .
19 | 
20 | .PARAMETER owner_id
21 |     The user ID of the user who owns the list being requested by a slug .
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-subscribers-destroy
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$list_id,
31 |         [string]$slug,
32 |         [string]$owner_screen_name,
33 |         [string]$owner_id
34 |     )
35 |     Begin {
36 | 
37 |         [hashtable]$Parameters = $PSBoundParameters
38 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
39 | 
40 |         [string]$Method      = 'POST'
41 |         [string]$Resource    = '/lists/subscribers/destroy'
42 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/subscribers/destroy.json'
43 | 
44 |     }
45 |     Process {
46 | 
47 |         # Find & Replace any ResourceUrl parameters.
48 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
49 |         ForEach ($UrlParameter in $UrlParameters) {
50 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
51 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
52 |         }
53 | 
54 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
55 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
56 | 
57 |     }
58 |     End {
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterLists_Update.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterLists_Update {
 2 | <#
 3 | .SYNOPSIS
 4 |     Create and manage lists
 5 | 
 6 | .DESCRIPTION
 7 |     POST lists/update
 8 |     
 9 |     Updates the specified list. The authenticated user must own the list to be able to update it.
10 | 
11 | .PARAMETER list_id
12 |     The numerical id of the list.
13 | 
14 | .PARAMETER slug
15 |     You can identify a list by its slug instead of its numerical id. If you decide to do so, note that you'll also have to specify the list owner using the owner_id or owner_screen_name parameters.
16 | 
17 | .PARAMETER mode
18 |     Whether your list is public or private. Values can be public or private . If no mode is specified the list will be public.
19 | 
20 | .PARAMETER description
21 |     The description to give the list.
22 | 
23 | .PARAMETER owner_screen_name
24 |     The screen name of the user who owns the list being requested by a slug .
25 | 
26 | .PARAMETER owner_id
27 |     The user ID of the user who owns the list being requested by a slug .
28 | 
29 | .NOTES
30 |     This helper function was generated by the information provided here:
31 |     https://developer.twitter.com/en/docs/accounts-and-users/create-manage-lists/api-reference/post-lists-update
32 | 
33 | #>
34 |     [CmdletBinding()]
35 |     Param(
36 |         [string]$list_id,
37 |         [string]$slug,
38 |         [string]$mode,
39 |         [string]$description,
40 |         [string]$owner_screen_name,
41 |         [string]$owner_id
42 |     )
43 |     Begin {
44 | 
45 |         [hashtable]$Parameters = $PSBoundParameters
46 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
47 | 
48 |         [string]$Method      = 'POST'
49 |         [string]$Resource    = '/lists/update'
50 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/lists/update.json'
51 | 
52 |     }
53 |     Process {
54 | 
55 |         # Find & Replace any ResourceUrl parameters.
56 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
57 |         ForEach ($UrlParameter in $UrlParameters) {
58 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
59 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
60 |         }
61 | 
62 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
63 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
64 | 
65 |     }
66 |     End {
67 | 
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterMedia_MetadataCreate.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterMedia_MetadataCreate {
 2 | <#
 3 | .SYNOPSIS
 4 |     Upload media
 5 | 
 6 | .DESCRIPTION
 7 |     POST media/metadata/create
 8 |     
 9 |     Overview
10 |     
11 |     This endpoint can be used to provide additional information about the uploaded media_id. This feature is currently only supported for images and GIFs.
12 |     
13 |     The request flow should be:
14 |     
15 |     Upload media using either the simple upload endpoint or the (preferred) chunked upload endpoint.
16 |     Call this endpoint to attach additional metadata such as image alt text.
17 |     Create Tweet with media_id(s) attached.
18 |     
19 |     Request
20 |     
21 |     Requests should be HTTP POST with a JSON content body, and Content-Type application/json; charset=UTF-8 or text/plain; charset=UTF-8.
22 |     
23 |     Note: The domain for this endpoint is upload.twitter.com
24 |     
25 |     Response
26 |     
27 |     A successful response returns HTTP 2xx.
28 | 
29 | 
30 | .NOTES
31 |     This helper function was generated by the information provided here:
32 |     https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-metadata-create
33 | 
34 | #>
35 |     [CmdletBinding()]
36 |     Param(
37 |         
38 |     )
39 |     Begin {
40 | 
41 |         [hashtable]$Parameters = $PSBoundParameters
42 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
43 | 
44 |         [string]$Method      = 'POST'
45 |         [string]$Resource    = '/media/metadata/create'
46 |         [string]$ResourceUrl = 'https://upload.twitter.com/1.1/media/metadata/create.json'
47 | 
48 |     }
49 |     Process {
50 | 
51 |         # Find & Replace any ResourceUrl parameters.
52 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
53 |         ForEach ($UrlParameter in $UrlParameters) {
54 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
55 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
56 |         }
57 | 
58 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
59 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
60 | 
61 |     }
62 |     End {
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterMedia_SubtitlesDelete.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterMedia_SubtitlesDelete {
 2 | <#
 3 | .SYNOPSIS
 4 |     Upload media
 5 | 
 6 | .DESCRIPTION
 7 |     POST media/subtitles/delete
 8 |     
 9 |     Overview
10 |     
11 |     Use this endpoint to dissociate subtitles from a video and delete the subtitles. You can dissociate subtitles from a video before or after Tweeting.
12 |     
13 |     Request
14 |     
15 |     Requests should be HTTP POST with a JSON content body, and Content-Type application/json; charset=UTF-8
16 |     
17 |     Note: The domain for this endpoint is upload.twitter.com
18 |     
19 |     Response Codes
20 |     
21 |     This endpoint returns the following HTTP responses:
22 |     
23 |     Status Text Description
24 |     200 OK The request to create the subtitle was successful.
25 |     400 Bad Request Generally, this response occurs due to the presence of invalid JSON in the request, or where the request failed to send any JSON payload. In this case this error could indicate an invalid subtitle file.
26 |     403 Unauthorized HTTP authentication failed due to invalid credentials. Check your OAuth keys and tokens.
27 |     404 Not Found The resource was not found at the URL to which the request was sent, likely because an incorrect media_id
28 |     500 Internal Server Error There was an error on Twitter's side. Retry your request using an exponential backoff pattern.
29 |     503 Service Unavailable There was an error on Twitter's side. Retry your request using an exponential backoff pattern.
30 | 
31 | 
32 | .NOTES
33 |     This helper function was generated by the information provided here:
34 |     https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-subtitles-delete
35 | 
36 | #>
37 |     [CmdletBinding()]
38 |     Param(
39 |         
40 |     )
41 |     Begin {
42 | 
43 |         [hashtable]$Parameters = $PSBoundParameters
44 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
45 | 
46 |         [string]$Method      = 'POST'
47 |         [string]$Resource    = '/media/subtitles/delete'
48 |         [string]$ResourceUrl = 'https://upload.twitter.com/1.1/media/subtitles/delete.json'
49 | 
50 |     }
51 |     Process {
52 | 
53 |         # Find & Replace any ResourceUrl parameters.
54 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
55 |         ForEach ($UrlParameter in $UrlParameters) {
56 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
57 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
58 |         }
59 | 
60 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
61 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
62 | 
63 |     }
64 |     End {
65 | 
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterMutes_UsersCreate.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterMutes_UsersCreate {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     POST mutes/users/create
 8 |     
 9 |     Mutes the user specified in the ID parameter for the authenticating user.
10 |     
11 |     Returns the muted user when successful. Returns a string describing the failure condition when unsuccessful.
12 |     
13 |     Actions taken in this method are asynchronous. Changes will be eventually consistent.
14 | 
15 | .PARAMETER screen_name
16 |     The screen name of the potentially muted user. Helpful for disambiguating when a valid screen name is also a user ID.
17 | 
18 | .PARAMETER user_id
19 |     The ID of the potentially muted user. Helpful for disambiguating when a valid user ID is also a valid screen name.
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/post-mutes-users-create
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$screen_name,
29 |         [string]$user_id
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/mutes/users/create'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/mutes/users/create.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterMutes_UsersDestroy.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterMutes_UsersDestroy {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     POST mutes/users/destroy
 8 |     
 9 |     Un-mutes the user specified in the ID parameter for the authenticating user.
10 |     
11 |     Returns the unmuted user when successful. Returns a string describing the failure condition when unsuccessful.
12 |     
13 |     Actions taken in this method are asynchronous. Changes will be eventually consistent.
14 | 
15 | .PARAMETER screen_name
16 |     The screen name of the potentially muted user. Helpful for disambiguating when a valid screen name is also a user ID.
17 | 
18 | .PARAMETER user_id
19 |     The ID of the potentially muted user. Helpful for disambiguating when a valid user ID is also a valid screen name.
20 | 
21 | .NOTES
22 |     This helper function was generated by the information provided here:
23 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/post-mutes-users-destroy
24 | 
25 | #>
26 |     [CmdletBinding()]
27 |     Param(
28 |         [string]$screen_name,
29 |         [string]$user_id
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/mutes/users/destroy'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/mutes/users/destroy.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterOauth2_InvalidateToken.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterOauth2_InvalidateToken {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     POST oauth2/invalidate_token
 8 |     
 9 |     Allows a registered application to revoke an issued OAuth 2 Bearer Token by presenting its client credentials. Once a Bearer Token has been invalidated, new creation attempts will yield a different Bearer Token and usage of the invalidated token will no longer be allowed.
10 |     
11 |     Successful responses include a JSON-structure describing the revoked Bearer Token.
12 | 
13 | .PARAMETER access_token
14 |     The value of the bearer token to revoke.
15 | 
16 | .NOTES
17 |     This helper function was generated by the information provided here:
18 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/invalidate_bearer_token
19 | 
20 | #>
21 |     [CmdletBinding()]
22 |     Param(
23 |         [string]$access_token
24 |     )
25 |     Begin {
26 | 
27 |         [hashtable]$Parameters = $PSBoundParameters
28 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
29 | 
30 |         [string]$Method      = 'POST'
31 |         [string]$Resource    = '/oauth2/invalidate_token'
32 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth2/invalidate_token'
33 | 
34 |     }
35 |     Process {
36 | 
37 |         # Find & Replace any ResourceUrl parameters.
38 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
39 |         ForEach ($UrlParameter in $UrlParameters) {
40 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
41 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
42 |         }
43 | 
44 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
45 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
46 | 
47 |     }
48 |     End {
49 | 
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterOauth2_Token.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterOauth2_Token {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     POST oauth2/token
 8 |     
 9 |     Allows a registered application to obtain an OAuth 2 Bearer Token, which can be used to make API requests on an application's own behalf, without a user context. This is called Application-only authentication.
10 |     
11 |     A Bearer Token may be invalidated using oauth2/invalidate_token. Once a Bearer Token has been invalidated, new creation attempts will yield a different Bearer Token and usage of the previous token will no longer be allowed.
12 |     
13 |     Only one bearer token may exist outstanding for an application, and repeated requests to this method will yield the same already-existent token until it has been invalidated.
14 |     
15 |     Successful responses include a JSON-structure describing the awarded Bearer Token.
16 |     
17 |     Tokens received by this method should be cached. If attempted too frequently, requests will be rejected with a HTTP 403 with code 99.
18 | 
19 | .PARAMETER grant_type
20 |     Specifies the type of grant being requested by the application. At this time, only client_credentials is allowed. See Application-Only Authentication for more information.
21 | 
22 | .NOTES
23 |     This helper function was generated by the information provided here:
24 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/token
25 | 
26 | #>
27 |     [CmdletBinding()]
28 |     Param(
29 |         [string]$grant_type
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/oauth2/token'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth2/token'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterOauth_AccessToken.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterOauth_AccessToken {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     POST oauth/access_token
 8 |     
 9 |     Allows a Consumer application to exchange the OAuth Request Token for an OAuth Access Token. This method fulfills Section 6.3 of the OAuth 1.0 authentication flow.
10 | 
11 | .PARAMETER oauth_verifier
12 |     If using the OAuth web-flow, set this parameter to the value of the oauth_verifier returned in the callback URL. If you are using out-of-band OAuth, set this value to the pin-code. For OAuth 1.0a compliance this parameter is required. OAuth 1.0a is strictly enforced and applications not using the oauth_verifier will fail to complete the OAuth flow.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/access_token
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$oauth_verifier
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'POST'
29 |         [string]$Resource    = '/oauth/access_token'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth/access_token'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterOauth_InvalidateToken.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterOauth_InvalidateToken {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     POST oauth/invalidate_token
 8 |     
 9 |     Allows a registered application to revoke an issued OAuth access_token by presenting its client credentials. Once an access_token has been invalidated, new creation attempts will yield a different Access Token and usage of the invalidated token will no longer be allowed.
10 | 
11 | .PARAMETER access_token
12 |     The access_token of user to be invalidated
13 | 
14 | .PARAMETER access_token_secret
15 |     The access_token_secret of user to be invalidated
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/invalidate_access_token
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$access_token,
25 |         [string]$access_token_secret
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'POST'
33 |         [string]$Resource    = '/oauth/invalidate_token'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth/invalidate_token'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterOauth_RequestToken.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterOauth_RequestToken {
 2 | <#
 3 | .SYNOPSIS
 4 |     Authentication
 5 | 
 6 | .DESCRIPTION
 7 |     POST oauth/request_token
 8 |     
 9 |     Allows a Consumer application to obtain an OAuth Request Token to request user authorization. This method fulfills Section 6.1 of the OAuth 1.0 authentication flow.
10 |     
11 |     We require you use HTTPS for all OAuth authorization steps.
12 |     
13 |     Usage Note: Only ASCII values are accepted for the oauth_nonce
14 | 
15 | .PARAMETER oauth_callback
16 |     For OAuth 1.0a compliance this parameter is required . The value you specify here will be used as the URL a user is redirected to should they approve your application's access to their account. Set this to oob for out-of-band pin mode. This is also how you specify custom callbacks for use in desktop/mobile applications. Always send an oauth_callback on this step, regardless of a pre-registered callback.
17 | We require that any callback URL used with this endpoint will have to be whitelisted within the app settings on developer.twitter.com*
18 | 
19 | .PARAMETER x_auth_access_type
20 |     Overrides the access level an application requests to a users account. Supported values are read or write . This parameter is intended to allow a developer to register a read/write application but also request read only access when appropriate.
21 | 
22 | .NOTES
23 |     This helper function was generated by the information provided here:
24 |     https://developer.twitter.com/en/docs/basics/authentication/api-reference/request_token
25 | 
26 | #>
27 |     [CmdletBinding()]
28 |     Param(
29 |         [string]$oauth_callback,
30 |         [string]$x_auth_access_type
31 |     )
32 |     Begin {
33 | 
34 |         [hashtable]$Parameters = $PSBoundParameters
35 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
36 | 
37 |         [string]$Method      = 'POST'
38 |         [string]$Resource    = '/oauth/request_token'
39 |         [string]$ResourceUrl = 'https://api.twitter.com/oauth/request_token'
40 | 
41 |     }
42 |     Process {
43 | 
44 |         # Find & Replace any ResourceUrl parameters.
45 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
46 |         ForEach ($UrlParameter in $UrlParameters) {
47 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
48 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
49 |         }
50 | 
51 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
52 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
53 | 
54 |     }
55 |     End {
56 | 
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterSavedSearches_Create.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterSavedSearches_Create {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     POST saved_searches/create
 8 |     
 9 |     Create a new saved search for the authenticated user. A user may only have 25 saved searches.
10 | 
11 | .PARAMETER query
12 |     The query of the search the user would like to save.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/post-saved_searches-create
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$query
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'POST'
29 |         [string]$Resource    = '/saved_searches/create'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/saved_searches/create.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterSavedSearches_Destroy_Id.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterSavedSearches_Destroy_Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Manage account settings and profile
 5 | 
 6 | .DESCRIPTION
 7 |     POST saved_searches/destroy/:id
 8 |     
 9 |     Destroys a saved search for the authenticating user. The authenticating user must be the owner of saved search id being destroyed.
10 | 
11 | .PARAMETER id
12 |     The ID of the saved search.
13 | 
14 | .NOTES
15 |     This helper function was generated by the information provided here:
16 |     https://developer.twitter.com/en/docs/accounts-and-users/manage-account-settings/api-reference/post-saved_searches-destroy-id
17 | 
18 | #>
19 |     [CmdletBinding()]
20 |     Param(
21 |         [string]$id
22 |     )
23 |     Begin {
24 | 
25 |         [hashtable]$Parameters = $PSBoundParameters
26 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
27 | 
28 |         [string]$Method      = 'POST'
29 |         [string]$Resource    = '/saved_searches/destroy/:id'
30 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/saved_searches/destroy/:id.json'
31 | 
32 |     }
33 |     Process {
34 | 
35 |         # Find & Replace any ResourceUrl parameters.
36 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
37 |         ForEach ($UrlParameter in $UrlParameters) {
38 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
39 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
40 |         }
41 | 
42 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
43 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
44 | 
45 |     }
46 |     End {
47 | 
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterStatuses_Destroy_Id.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterStatuses_Destroy_Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST statuses/destroy/:id
 8 |     
 9 |     Destroys the status specified by the required ID parameter. The authenticating user must be the author of the specified status. Returns the destroyed status if successful.
10 | 
11 | .PARAMETER id
12 |     The numerical ID of the desired status.
13 | 
14 | .PARAMETER trim_user
15 |     When set to either true , t or 1 , each tweet returned in a timeline will include a user object including only the status authors numerical ID. Omit this parameter to receive the complete user object.
16 | 
17 | .NOTES
18 |     This helper function was generated by the information provided here:
19 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-statuses-destroy-id
20 | 
21 | #>
22 |     [CmdletBinding()]
23 |     Param(
24 |         [string]$id,
25 |         [string]$trim_user
26 |     )
27 |     Begin {
28 | 
29 |         [hashtable]$Parameters = $PSBoundParameters
30 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
31 | 
32 |         [string]$Method      = 'POST'
33 |         [string]$Resource    = '/statuses/destroy/:id'
34 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/statuses/destroy/:id.json'
35 | 
36 |     }
37 |     Process {
38 | 
39 |         # Find & Replace any ResourceUrl parameters.
40 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
41 |         ForEach ($UrlParameter in $UrlParameters) {
42 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
43 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
44 |         }
45 | 
46 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
47 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
48 | 
49 |     }
50 |     End {
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterStatuses_Retweet_Id.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterStatuses_Retweet_Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST statuses/retweet/:id
 8 |     
 9 |     Retweets a tweet. Returns the original Tweet with Retweet details embedded.
10 |     
11 |     Usage Notes:
12 |     
13 |     This method is subject to update limits. A HTTP 403 will be returned if this limit as been hit.
14 |     Twitter will ignore attempts to perform duplicate retweets.
15 |     The retweet_count will be current as of when the payload is generated and may not reflect the exact count. It is intended as an approximation.
16 | 
17 | .PARAMETER id
18 |     The numerical ID of the desired status.
19 | 
20 | .PARAMETER trim_user
21 |     When set to either true , t or 1 , each tweet returned in a timeline will include a user object including only the status authors numerical ID. Omit this parameter to receive the complete user object.
22 | 
23 | .NOTES
24 |     This helper function was generated by the information provided here:
25 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-statuses-retweet-id
26 | 
27 | #>
28 |     [CmdletBinding()]
29 |     Param(
30 |         [string]$id,
31 |         [string]$trim_user
32 |     )
33 |     Begin {
34 | 
35 |         [hashtable]$Parameters = $PSBoundParameters
36 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
37 | 
38 |         [string]$Method      = 'POST'
39 |         [string]$Resource    = '/statuses/retweet/:id'
40 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/statuses/retweet/:id.json'
41 | 
42 |     }
43 |     Process {
44 | 
45 |         # Find & Replace any ResourceUrl parameters.
46 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
47 |         ForEach ($UrlParameter in $UrlParameters) {
48 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
49 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
50 |         }
51 | 
52 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
53 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
54 | 
55 |     }
56 |     End {
57 | 
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterStatuses_Unretweet_Id.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterStatuses_Unretweet_Id {
 2 | <#
 3 | .SYNOPSIS
 4 |     Post, retrieve and engage with Tweets
 5 | 
 6 | .DESCRIPTION
 7 |     POST statuses/unretweet/:id
 8 |     
 9 |     Untweets a retweeted status. Returns the original Tweet with Retweet details embedded.
10 |     
11 |     Usage Notes:
12 |     
13 |     This method is subject to update limits. A HTTP 429 will be returned if this limit has been hit.
14 |     The untweeted retweet status ID must be authored by the user backing the authentication token.
15 |     An application must have write privileges to POST. A HTTP 401 will be returned for read-only applications.
16 |     When passing a source status ID instead of the retweet status ID a HTTP 200 response will be returned with the same Tweet object but no action.
17 | 
18 | .PARAMETER id
19 |     The numerical ID of the desired status.
20 | 
21 | .PARAMETER trim_user
22 |     When set to either true , t or 1 , each Tweet returned in a timeline will include a user object including only the status authors numerical ID. Omit this parameter to receive the complete user object.
23 | 
24 | .NOTES
25 |     This helper function was generated by the information provided here:
26 |     https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-statuses-unretweet-id
27 | 
28 | #>
29 |     [CmdletBinding()]
30 |     Param(
31 |         [string]$id,
32 |         [string]$trim_user
33 |     )
34 |     Begin {
35 | 
36 |         [hashtable]$Parameters = $PSBoundParameters
37 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
38 | 
39 |         [string]$Method      = 'POST'
40 |         [string]$Resource    = '/statuses/unretweet/:id'
41 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/statuses/unretweet/:id.json'
42 | 
43 |     }
44 |     Process {
45 | 
46 |         # Find & Replace any ResourceUrl parameters.
47 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
48 |         ForEach ($UrlParameter in $UrlParameters) {
49 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
50 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
51 |         }
52 | 
53 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
54 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
55 | 
56 |     }
57 |     End {
58 | 
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/PSTwitterAPI/public/helper/Send-TwitterUsers_ReportSpam.ps1:
--------------------------------------------------------------------------------
 1 | function Send-TwitterUsers_ReportSpam {
 2 | <#
 3 | .SYNOPSIS
 4 |     Mute, block and report users
 5 | 
 6 | .DESCRIPTION
 7 |     POST users/report_spam
 8 |     
 9 |     Report the specified user as a spam account to Twitter. Additionally, optionally performs the equivalent of POST blocks / create on behalf of the authenticated user.
10 | 
11 | .PARAMETER screen_name
12 |     The screen_name of the user to report as a spammer. Helpful for disambiguating when a valid screen name is also a user ID.
13 | 
14 | .PARAMETER user_id
15 |     The ID of the user to report as a spammer. Helpful for disambiguating when a valid user ID is also a valid screen name.
16 | 
17 | .PARAMETER perform_block
18 |     Whether the account should be blocked by the authenticated user, as well as being reported for spam.
19 | 
20 | .NOTES
21 |     This helper function was generated by the information provided here:
22 |     https://developer.twitter.com/en/docs/accounts-and-users/mute-block-report-users/api-reference/post-users-report_spam
23 | 
24 | #>
25 |     [CmdletBinding()]
26 |     Param(
27 |         [string]$screen_name,
28 |         [string]$user_id,
29 |         [string]$perform_block
30 |     )
31 |     Begin {
32 | 
33 |         [hashtable]$Parameters = $PSBoundParameters
34 |                    $CmdletBindingParameters | ForEach-Object { $Parameters.Remove($_) }
35 | 
36 |         [string]$Method      = 'POST'
37 |         [string]$Resource    = '/users/report_spam'
38 |         [string]$ResourceUrl = 'https://api.twitter.com/1.1/users/report_spam.json'
39 | 
40 |     }
41 |     Process {
42 | 
43 |         # Find & Replace any ResourceUrl parameters.
44 |         $UrlParameters = [regex]::Matches($ResourceUrl, '(?<!\w):\w+')
45 |         ForEach ($UrlParameter in $UrlParameters) {
46 |             $UrlParameterValue = $Parameters["$($UrlParameter.Value.TrimStart(":"))"]
47 |             $ResourceUrl = $ResourceUrl -Replace $UrlParameter.Value, $UrlParameterValue
48 |         }
49 | 
50 |         $OAuthSettings = Get-TwitterOAuthSettings -Resource $Resource
51 |         Invoke-TwitterAPI -Method $Method -ResourceUrl $ResourceUrl -Parameters $Parameters -OAuthSettings $OAuthSettings
52 | 
53 |     }
54 |     End {
55 | 
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/Tests/PSTwitterAPI.Tests.ps1:
--------------------------------------------------------------------------------
 1 | Try { Set-BuildEnvironment -Path "${PSScriptRoot}\.." -ErrorAction SilentlyContinue -Force } Catch { }
 2 | 
 3 | Remove-Module $ENV:BHProjectName -ErrorAction SilentlyContinue -Force -Confirm:$False
 4 | $Script:Module = Import-Module $ENV:BHPSModuleManifest -Force -PassThru
 5 | 
 6 | Describe 'Get-Module -Name PSTwitterAPI' {
 7 |     Context 'Strict mode' {
 8 | 
 9 |         Set-StrictMode -Version Latest
10 | 
11 |         It 'Should Import' {
12 |             $Script:Module.Name | Should be $ENV:BHProjectName
13 |         }
14 |         It 'Should have ExportedFunctions' {
15 |             $Script:Module.ExportedFunctions.Keys -contains 'Get-TwitterOAuthSettings' | Should be $True
16 |             $Script:Module.ExportedFunctions.Keys -contains 'Set-TwitterOAuthSettings' | Should be $True
17 |             $Script:Module.ExportedFunctions.Keys -contains 'Invoke-TwitterAPI' | Should be $True
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/azure-pipelines.yml:
--------------------------------------------------------------------------------
 1 | name: $(Build.DefinitionName)_$(Date:yyyyMMdd)
 2 | 
 3 | resources:
 4 | - repo: self
 5 | 
 6 | queue:
 7 |   name: Hosted VS2017
 8 | 
 9 | steps:
10 | - powershell: './PSTwitterAPI.bootstrap.ps1'
11 |   displayName: 'Invoke Bootstrap'
12 | 
13 | - powershell: 'Invoke-Build -Configuration Production -Task Test'
14 |   displayName: 'Invoke Pester Tests'
15 | 
16 | - task: PublishTestResults@2
17 |   displayName: 'Publish Test Results'
18 |   inputs:
19 |     testResultsFormat: NUnit
20 |     testResultsFiles: 'TestResults-*.xml'
21 |     searchFolder: '$(System.DefaultWorkingDirectory)/TestResults'
22 | 
23 | - task: PublishCodeCoverageResults@1
24 |   displayName: 'Publish Code Coverage'
25 |   inputs:
26 |     summaryFileLocation: '$(System.DefaultWorkingDirectory)/TestResults/CodeCoverage-*.xml'
27 |     reportDirectory: '$(System.DefaultWorkingDirectory)/TestResults'
28 | 
29 | - task: PublishBuildArtifacts@1
30 |   displayName: 'Publish Artifact: PSTwitterAPI'
31 |   inputs:
32 |     PathtoPublish: '$(System.DefaultWorkingDirectory)/PSTwitterAPI'
33 |     ArtifactName: PSTwitterAPI
34 | 
35 | - powershell: 'Invoke-Build -Configuration Production -Task UpdateManifest, PublishModule'
36 |   displayName: 'Publish PowerShell Module'


--------------------------------------------------------------------------------