synchronizationjob

package
v0.20241104.1140654 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 4, 2024 License: MPL-2.0 Imports: 9 Imported by: 0

README

github.com/hashicorp/go-azure-sdk/microsoft-graph/serviceprincipals/beta/synchronizationjob Documentation

The synchronizationjob SDK allows for interaction with Microsoft Graph serviceprincipals (API Version beta).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-sdk/microsoft-graph/serviceprincipals/beta/synchronizationjob"

Client Initialization

client := synchronizationjob.NewSynchronizationJobClientWithBaseURI("https://graph.microsoft.com")
client.Client.Authorizer = authorizer

Example Usage: SynchronizationJobClient.CreateSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalID("servicePrincipalId")

payload := synchronizationjob.SynchronizationJob{
	// ...
}


read, err := client.CreateSynchronizationJob(ctx, id, payload, synchronizationjob.DefaultCreateSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.DeleteSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

read, err := client.DeleteSynchronizationJob(ctx, id, synchronizationjob.DefaultDeleteSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.GetSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

read, err := client.GetSynchronizationJob(ctx, id, synchronizationjob.DefaultGetSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.GetSynchronizationJobsCount

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalID("servicePrincipalId")

read, err := client.GetSynchronizationJobsCount(ctx, id, synchronizationjob.DefaultGetSynchronizationJobsCountOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.ListSynchronizationJobs

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalID("servicePrincipalId")

// alternatively `client.ListSynchronizationJobs(ctx, id, synchronizationjob.DefaultListSynchronizationJobsOperationOptions())` can be used to do batched pagination
items, err := client.ListSynchronizationJobsComplete(ctx, id, synchronizationjob.DefaultListSynchronizationJobsOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: SynchronizationJobClient.PauseSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

read, err := client.PauseSynchronizationJob(ctx, id, synchronizationjob.DefaultPauseSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.ProvisionSynchronizationJobOnDemand

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

payload := synchronizationjob.ProvisionSynchronizationJobOnDemandRequest{
	// ...
}


read, err := client.ProvisionSynchronizationJobOnDemand(ctx, id, payload, synchronizationjob.DefaultProvisionSynchronizationJobOnDemandOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.RestartSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

payload := synchronizationjob.RestartSynchronizationJobRequest{
	// ...
}


read, err := client.RestartSynchronizationJob(ctx, id, payload, synchronizationjob.DefaultRestartSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.StartSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

read, err := client.StartSynchronizationJob(ctx, id, synchronizationjob.DefaultStartSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.UpdateSynchronizationJob

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

payload := synchronizationjob.SynchronizationJob{
	// ...
}


read, err := client.UpdateSynchronizationJob(ctx, id, payload, synchronizationjob.DefaultUpdateSynchronizationJobOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.ValidateSynchronizationJobCredentials

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalIdSynchronizationJobID("servicePrincipalId", "synchronizationJobId")

payload := synchronizationjob.ValidateSynchronizationJobCredentialsRequest{
	// ...
}


read, err := client.ValidateSynchronizationJobCredentials(ctx, id, payload, synchronizationjob.DefaultValidateSynchronizationJobCredentialsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: SynchronizationJobClient.ValidateSynchronizationJobsCredentials

ctx := context.TODO()
id := synchronizationjob.NewServicePrincipalID("servicePrincipalId")

payload := synchronizationjob.ValidateSynchronizationJobsCredentialsRequest{
	// ...
}


read, err := client.ValidateSynchronizationJobsCredentials(ctx, id, payload, synchronizationjob.DefaultValidateSynchronizationJobsCredentialsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CreateSynchronizationJobOperationOptions 

type CreateSynchronizationJobOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultCreateSynchronizationJobOperationOptions 

func DefaultCreateSynchronizationJobOperationOptions() CreateSynchronizationJobOperationOptions

func (CreateSynchronizationJobOperationOptions) ToHeaders 

func (o CreateSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (CreateSynchronizationJobOperationOptions) ToOData 

func (o CreateSynchronizationJobOperationOptions) ToOData() *odata.Query

func (CreateSynchronizationJobOperationOptions) ToQuery 

func (o CreateSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type CreateSynchronizationJobOperationResponse 

type CreateSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *beta.SynchronizationJob
}

type DeleteSynchronizationJobOperationOptions 

type DeleteSynchronizationJobOperationOptions struct {
	IfMatch   *string
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultDeleteSynchronizationJobOperationOptions 

func DefaultDeleteSynchronizationJobOperationOptions() DeleteSynchronizationJobOperationOptions

func (DeleteSynchronizationJobOperationOptions) ToHeaders 

func (o DeleteSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (DeleteSynchronizationJobOperationOptions) ToOData 

func (o DeleteSynchronizationJobOperationOptions) ToOData() *odata.Query

func (DeleteSynchronizationJobOperationOptions) ToQuery 

func (o DeleteSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type DeleteSynchronizationJobOperationResponse 

type DeleteSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type GetSynchronizationJobOperationOptions 

type GetSynchronizationJobOperationOptions struct {
	Expand    *odata.Expand
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
	Select    *[]string
}

func DefaultGetSynchronizationJobOperationOptions 

func DefaultGetSynchronizationJobOperationOptions() GetSynchronizationJobOperationOptions

func (GetSynchronizationJobOperationOptions) ToHeaders 

func (o GetSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (GetSynchronizationJobOperationOptions) ToOData 

func (o GetSynchronizationJobOperationOptions) ToOData() *odata.Query

func (GetSynchronizationJobOperationOptions) ToQuery 

func (o GetSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type GetSynchronizationJobOperationResponse 

type GetSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *beta.SynchronizationJob
}

type GetSynchronizationJobsCountOperationOptions 

type GetSynchronizationJobsCountOperationOptions struct {
	Filter    *string
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
	Search    *string
}

func DefaultGetSynchronizationJobsCountOperationOptions 

func DefaultGetSynchronizationJobsCountOperationOptions() GetSynchronizationJobsCountOperationOptions

func (GetSynchronizationJobsCountOperationOptions) ToHeaders 

func (o GetSynchronizationJobsCountOperationOptions) ToHeaders() *client.Headers

func (GetSynchronizationJobsCountOperationOptions) ToOData 

func (o GetSynchronizationJobsCountOperationOptions) ToOData() *odata.Query

func (GetSynchronizationJobsCountOperationOptions) ToQuery 

func (o GetSynchronizationJobsCountOperationOptions) ToQuery() *client.QueryParams

type GetSynchronizationJobsCountOperationResponse 

type GetSynchronizationJobsCountOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]byte
}

type ListSynchronizationJobsCompleteResult 

type ListSynchronizationJobsCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []beta.SynchronizationJob
}

type ListSynchronizationJobsCustomPager 

type ListSynchronizationJobsCustomPager struct {
	NextLink *odata.Link `json:"@odata.nextLink"`
}
func (p *ListSynchronizationJobsCustomPager) NextPageLink() *odata.Link

type ListSynchronizationJobsOperationOptions 

type ListSynchronizationJobsOperationOptions struct {
	Count     *bool
	Expand    *odata.Expand
	Filter    *string
	Metadata  *odata.Metadata
	OrderBy   *odata.OrderBy
	RetryFunc client.RequestRetryFunc
	Search    *string
	Select    *[]string
	Skip      *int64
	Top       *int64
}

func DefaultListSynchronizationJobsOperationOptions 

func DefaultListSynchronizationJobsOperationOptions() ListSynchronizationJobsOperationOptions

func (ListSynchronizationJobsOperationOptions) ToHeaders 

func (o ListSynchronizationJobsOperationOptions) ToHeaders() *client.Headers

func (ListSynchronizationJobsOperationOptions) ToOData 

func (o ListSynchronizationJobsOperationOptions) ToOData() *odata.Query

func (ListSynchronizationJobsOperationOptions) ToQuery 

func (o ListSynchronizationJobsOperationOptions) ToQuery() *client.QueryParams

type ListSynchronizationJobsOperationResponse 

type ListSynchronizationJobsOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]beta.SynchronizationJob
}

type PauseSynchronizationJobOperationOptions 

type PauseSynchronizationJobOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultPauseSynchronizationJobOperationOptions 

func DefaultPauseSynchronizationJobOperationOptions() PauseSynchronizationJobOperationOptions

func (PauseSynchronizationJobOperationOptions) ToHeaders 

func (o PauseSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (PauseSynchronizationJobOperationOptions) ToOData 

func (o PauseSynchronizationJobOperationOptions) ToOData() *odata.Query

func (PauseSynchronizationJobOperationOptions) ToQuery 

func (o PauseSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type PauseSynchronizationJobOperationResponse 

type PauseSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type ProvisionSynchronizationJobOnDemandOperationOptions 

type ProvisionSynchronizationJobOnDemandOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultProvisionSynchronizationJobOnDemandOperationOptions 

func DefaultProvisionSynchronizationJobOnDemandOperationOptions() ProvisionSynchronizationJobOnDemandOperationOptions

func (ProvisionSynchronizationJobOnDemandOperationOptions) ToHeaders 

func (o ProvisionSynchronizationJobOnDemandOperationOptions) ToHeaders() *client.Headers

func (ProvisionSynchronizationJobOnDemandOperationOptions) ToOData 

func (o ProvisionSynchronizationJobOnDemandOperationOptions) ToOData() *odata.Query

func (ProvisionSynchronizationJobOnDemandOperationOptions) ToQuery 

func (o ProvisionSynchronizationJobOnDemandOperationOptions) ToQuery() *client.QueryParams

type ProvisionSynchronizationJobOnDemandOperationResponse 

type ProvisionSynchronizationJobOnDemandOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *beta.StringKeyStringValuePair
}

type ProvisionSynchronizationJobOnDemandRequest 

type ProvisionSynchronizationJobOnDemandRequest struct {
	Parameters *[]beta.SynchronizationJobApplicationParameters `json:"parameters,omitempty"`
}

type RestartSynchronizationJobOperationOptions 

type RestartSynchronizationJobOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultRestartSynchronizationJobOperationOptions 

func DefaultRestartSynchronizationJobOperationOptions() RestartSynchronizationJobOperationOptions

func (RestartSynchronizationJobOperationOptions) ToHeaders 

func (o RestartSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (RestartSynchronizationJobOperationOptions) ToOData 

func (o RestartSynchronizationJobOperationOptions) ToOData() *odata.Query

func (RestartSynchronizationJobOperationOptions) ToQuery 

func (o RestartSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type RestartSynchronizationJobOperationResponse 

type RestartSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type RestartSynchronizationJobRequest 

type RestartSynchronizationJobRequest struct {
	Criteria *beta.SynchronizationJobRestartCriteria `json:"criteria,omitempty"`
}

type StartSynchronizationJobOperationOptions 

type StartSynchronizationJobOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultStartSynchronizationJobOperationOptions 

func DefaultStartSynchronizationJobOperationOptions() StartSynchronizationJobOperationOptions

func (StartSynchronizationJobOperationOptions) ToHeaders 

func (o StartSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (StartSynchronizationJobOperationOptions) ToOData 

func (o StartSynchronizationJobOperationOptions) ToOData() *odata.Query

func (StartSynchronizationJobOperationOptions) ToQuery 

func (o StartSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type StartSynchronizationJobOperationResponse 

type StartSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type SynchronizationJobClient 

type SynchronizationJobClient struct {
	Client *msgraph.Client
}

func NewSynchronizationJobClientWithBaseURI 

func NewSynchronizationJobClientWithBaseURI(sdkApi sdkEnv.Api) (*SynchronizationJobClient, error)

func (SynchronizationJobClient) CreateSynchronizationJob 

func (c SynchronizationJobClient) CreateSynchronizationJob(ctx context.Context, id beta.ServicePrincipalId, input beta.SynchronizationJob, options CreateSynchronizationJobOperationOptions) (result CreateSynchronizationJobOperationResponse, err error)

CreateSynchronizationJob - Create synchronizationJob. Create new synchronization job with a default synchronization schema. The job is created in a disabled state. Call Start job to start synchronization.

func (SynchronizationJobClient) DeleteSynchronizationJob 

func (c SynchronizationJobClient) DeleteSynchronizationJob(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, options DeleteSynchronizationJobOperationOptions) (result DeleteSynchronizationJobOperationResponse, err error)

DeleteSynchronizationJob - Delete synchronizationJob. Stop the synchronization job, and permanently delete all the state associated with it. Synchronized accounts are left as-is.

func (SynchronizationJobClient) GetSynchronizationJob 

func (c SynchronizationJobClient) GetSynchronizationJob(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, options GetSynchronizationJobOperationOptions) (result GetSynchronizationJobOperationResponse, err error)

GetSynchronizationJob - Get synchronizationJob. Retrieve the existing synchronization job and its properties.

func (SynchronizationJobClient) GetSynchronizationJobsCount 

func (c SynchronizationJobClient) GetSynchronizationJobsCount(ctx context.Context, id beta.ServicePrincipalId, options GetSynchronizationJobsCountOperationOptions) (result GetSynchronizationJobsCountOperationResponse, err error)

GetSynchronizationJobsCount - Get the number of the resource

func (SynchronizationJobClient) ListSynchronizationJobs 

func (c SynchronizationJobClient) ListSynchronizationJobs(ctx context.Context, id beta.ServicePrincipalId, options ListSynchronizationJobsOperationOptions) (result ListSynchronizationJobsOperationResponse, err error)

ListSynchronizationJobs - List synchronization jobs. List existing jobs for a given application instance (service principal).

func (SynchronizationJobClient) ListSynchronizationJobsComplete 

func (c SynchronizationJobClient) ListSynchronizationJobsComplete(ctx context.Context, id beta.ServicePrincipalId, options ListSynchronizationJobsOperationOptions) (ListSynchronizationJobsCompleteResult, error)

ListSynchronizationJobsComplete retrieves all the results into a single object

func (SynchronizationJobClient) ListSynchronizationJobsCompleteMatchingPredicate 

func (c SynchronizationJobClient) ListSynchronizationJobsCompleteMatchingPredicate(ctx context.Context, id beta.ServicePrincipalId, options ListSynchronizationJobsOperationOptions, predicate SynchronizationJobOperationPredicate) (result ListSynchronizationJobsCompleteResult, err error)

ListSynchronizationJobsCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (SynchronizationJobClient) PauseSynchronizationJob 

func (c SynchronizationJobClient) PauseSynchronizationJob(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, options PauseSynchronizationJobOperationOptions) (result PauseSynchronizationJobOperationResponse, err error)

PauseSynchronizationJob - Invoke action pause. Temporarily stop a running synchronization job. All the progress, including job state, is persisted, and the job continues from where it left off when a start call is made.

func (SynchronizationJobClient) ProvisionSynchronizationJobOnDemand 

func (c SynchronizationJobClient) ProvisionSynchronizationJobOnDemand(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, input ProvisionSynchronizationJobOnDemandRequest, options ProvisionSynchronizationJobOnDemandOperationOptions) (result ProvisionSynchronizationJobOnDemandOperationResponse, err error)

ProvisionSynchronizationJobOnDemand - Invoke action provisionOnDemand. Select a user and provision the account on-demand. The rate limit for this API is 5 requests per 10 seconds. No user or group will be provisioned on-demand that would not have been provisioned through the regular provisioning cycles.

func (SynchronizationJobClient) RestartSynchronizationJob 

func (c SynchronizationJobClient) RestartSynchronizationJob(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, input RestartSynchronizationJobRequest, options RestartSynchronizationJobOperationOptions) (result RestartSynchronizationJobOperationResponse, err error)

RestartSynchronizationJob - Invoke action restart. Restart a stopped synchronization job, forcing it to reprocess all the objects in the directory. Optionally clears existing the synchronization state and previous errors.

func (SynchronizationJobClient) StartSynchronizationJob 

func (c SynchronizationJobClient) StartSynchronizationJob(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, options StartSynchronizationJobOperationOptions) (result StartSynchronizationJobOperationResponse, err error)

StartSynchronizationJob - Invoke action start. Start an existing synchronization job. If the job is in a paused state, it continues processing changes from the point where it was paused. If the job is in quarantine, the quarantine status is cleared. Don't create scripts to call the start job continuously while it's running because that can cause the service to stop running. Use the start job only when the job is currently paused or in quarantine.

func (SynchronizationJobClient) UpdateSynchronizationJob 

func (c SynchronizationJobClient) UpdateSynchronizationJob(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, input beta.SynchronizationJob, options UpdateSynchronizationJobOperationOptions) (result UpdateSynchronizationJobOperationResponse, err error)

UpdateSynchronizationJob - Update the navigation property jobs in servicePrincipals

func (SynchronizationJobClient) ValidateSynchronizationJobCredentials 

func (c SynchronizationJobClient) ValidateSynchronizationJobCredentials(ctx context.Context, id beta.ServicePrincipalIdSynchronizationJobId, input ValidateSynchronizationJobCredentialsRequest, options ValidateSynchronizationJobCredentialsOperationOptions) (result ValidateSynchronizationJobCredentialsOperationResponse, err error)

ValidateSynchronizationJobCredentials - Invoke action validateCredentials. Validate that the credentials are valid in the tenant.

func (SynchronizationJobClient) ValidateSynchronizationJobsCredentials 

func (c SynchronizationJobClient) ValidateSynchronizationJobsCredentials(ctx context.Context, id beta.ServicePrincipalId, input ValidateSynchronizationJobsCredentialsRequest, options ValidateSynchronizationJobsCredentialsOperationOptions) (result ValidateSynchronizationJobsCredentialsOperationResponse, err error)

ValidateSynchronizationJobsCredentials - Invoke action validateCredentials

type SynchronizationJobOperationPredicate 

type SynchronizationJobOperationPredicate struct {
}

func (SynchronizationJobOperationPredicate) Matches 

func (p SynchronizationJobOperationPredicate) Matches(input beta.SynchronizationJob) bool

type UpdateSynchronizationJobOperationOptions 

type UpdateSynchronizationJobOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultUpdateSynchronizationJobOperationOptions 

func DefaultUpdateSynchronizationJobOperationOptions() UpdateSynchronizationJobOperationOptions

func (UpdateSynchronizationJobOperationOptions) ToHeaders 

func (o UpdateSynchronizationJobOperationOptions) ToHeaders() *client.Headers

func (UpdateSynchronizationJobOperationOptions) ToOData 

func (o UpdateSynchronizationJobOperationOptions) ToOData() *odata.Query

func (UpdateSynchronizationJobOperationOptions) ToQuery 

func (o UpdateSynchronizationJobOperationOptions) ToQuery() *client.QueryParams

type UpdateSynchronizationJobOperationResponse 

type UpdateSynchronizationJobOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type ValidateSynchronizationJobCredentialsOperationOptions 

type ValidateSynchronizationJobCredentialsOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultValidateSynchronizationJobCredentialsOperationOptions 

func DefaultValidateSynchronizationJobCredentialsOperationOptions() ValidateSynchronizationJobCredentialsOperationOptions

func (ValidateSynchronizationJobCredentialsOperationOptions) ToHeaders 

func (o ValidateSynchronizationJobCredentialsOperationOptions) ToHeaders() *client.Headers

func (ValidateSynchronizationJobCredentialsOperationOptions) ToOData 

func (o ValidateSynchronizationJobCredentialsOperationOptions) ToOData() *odata.Query

func (ValidateSynchronizationJobCredentialsOperationOptions) ToQuery 

func (o ValidateSynchronizationJobCredentialsOperationOptions) ToQuery() *client.QueryParams

type ValidateSynchronizationJobCredentialsOperationResponse 

type ValidateSynchronizationJobCredentialsOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type ValidateSynchronizationJobCredentialsRequest 

type ValidateSynchronizationJobCredentialsRequest struct {
	ApplicationIdentifier nullable.Type[string]                           `json:"applicationIdentifier,omitempty"`
	Credentials           *[]beta.SynchronizationSecretKeyStringValuePair `json:"credentials,omitempty"`
	TemplateId            nullable.Type[string]                           `json:"templateId,omitempty"`
	UseSavedCredentials   nullable.Type[bool]                             `json:"useSavedCredentials,omitempty"`
}

type ValidateSynchronizationJobsCredentialsOperationOptions 

type ValidateSynchronizationJobsCredentialsOperationOptions struct {
	Metadata  *odata.Metadata
	RetryFunc client.RequestRetryFunc
}

func DefaultValidateSynchronizationJobsCredentialsOperationOptions 

func DefaultValidateSynchronizationJobsCredentialsOperationOptions() ValidateSynchronizationJobsCredentialsOperationOptions

func (ValidateSynchronizationJobsCredentialsOperationOptions) ToHeaders 

func (o ValidateSynchronizationJobsCredentialsOperationOptions) ToHeaders() *client.Headers

func (ValidateSynchronizationJobsCredentialsOperationOptions) ToOData 

func (o ValidateSynchronizationJobsCredentialsOperationOptions) ToOData() *odata.Query

func (ValidateSynchronizationJobsCredentialsOperationOptions) ToQuery 

func (o ValidateSynchronizationJobsCredentialsOperationOptions) ToQuery() *client.QueryParams

type ValidateSynchronizationJobsCredentialsOperationResponse 

type ValidateSynchronizationJobsCredentialsOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type ValidateSynchronizationJobsCredentialsRequest 

type ValidateSynchronizationJobsCredentialsRequest struct {
	ApplicationIdentifier nullable.Type[string]                           `json:"applicationIdentifier,omitempty"`
	Credentials           *[]beta.SynchronizationSecretKeyStringValuePair `json:"credentials,omitempty"`
	TemplateId            nullable.Type[string]                           `json:"templateId,omitempty"`
	UseSavedCredentials   nullable.Type[bool]                             `json:"useSavedCredentials,omitempty"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.