verifiedpermissions

package module
v1.13.1 Latest Latest
Warning

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

 Go to latest Published: Apr 11, 2024 License: Apache-2.0 Imports: 41 Imported by: 5

Documentation

Overview

Package verifiedpermissions provides the API client, operations, and parameter types for Amazon Verified Permissions.

Amazon Verified Permissions is a permissions management service from Amazon Web Services. You can use Verified Permissions to manage permissions for your application, and authorize user access based on those permissions. Using Verified Permissions, application developers can grant access based on information about the users, resources, and requested actions. You can also evaluate additional information like group membership, attributes of the resources, and session context, such as time of request and IP addresses. Verified Permissions manages these permissions by letting you create and store authorization policies for your applications, such as consumer-facing web sites and enterprise business systems. Verified Permissions uses Cedar as the policy language to express your permission requirements. Cedar supports both role-based access control (RBAC) and attribute-based access control (ABAC) authorization models. For more information about configuring, administering, and using Amazon Verified Permissions in your applications, see the Amazon Verified Permissions User Guide (https://docs.aws.amazon.com/verifiedpermissions/latest/userguide/) . For more information about the Cedar policy language, see the Cedar Policy Language Guide (https://docs.cedarpolicy.com/) . When you write Cedar policies that reference principals, resources and actions, you can define the unique identifiers used for each of those elements. We strongly recommend that you follow these best practices:

  • Use values like universally unique identifiers (UUIDs) for all principal and resource identifiers. For example, if user jane leaves the company, and you later let someone else use the name jane , then that new user automatically gets access to everything granted by policies that still reference User::"jane" . Cedar can’t distinguish between the new user and the old. This applies to both principal and resource identifiers. Always use identifiers that are guaranteed unique and never reused to ensure that you don’t unintentionally grant access because of the presence of an old identifier in a policy. Where you use a UUID for an entity, we recommend that you follow it with the // comment specifier and the ‘friendly’ name of your entity. This helps to make your policies easier to understand. For example: principal == User::"a1b2c3d4-e5f6-a1b2-c3d4-EXAMPLE11111", // alice
  • Do not include personally identifying, confidential, or sensitive information as part of the unique identifier for your principals or resources. These identifiers are included in log entries shared in CloudTrail trails.

Several operations return structures that appear similar, but have different purposes. As new functionality is added to the product, the structure used in a parameter of one operation might need to change in a way that wouldn't make sense for the same parameter in a different operation. To help you understand the purpose of each, the following naming convention is used for the structures:

  • Parameter type structures that end in Detail are used in Get operations.
  • Parameter type structures that end in Item are used in List operations.
  • Parameter type structures that use neither suffix are used in the mutating (create and update) operations.

Index

Constants

View Source 
const ServiceAPIVersion = "2021-12-01"
View Source 
const ServiceID = "VerifiedPermissions"

Variables

This section is empty.

Functions

func NewDefaultEndpointResolver 

func NewDefaultEndpointResolver() *internalendpoints.Resolver

NewDefaultEndpointResolver constructs a new service endpoint resolver

func WithAPIOptions 

func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

WithAPIOptions returns a functional option for setting the Client's APIOptions option.

func WithEndpointResolver deprecated 

func WithEndpointResolver(v EndpointResolver) func(*Options)

Deprecated: EndpointResolver and WithEndpointResolver. Providing a value for this field will likely prevent you from using any endpoint-related service features released after the introduction of EndpointResolverV2 and BaseEndpoint. To migrate an EndpointResolver implementation that uses a custom endpoint, set the client option BaseEndpoint instead.

func WithEndpointResolverV2 added in v1.1.0 

func WithEndpointResolverV2(v EndpointResolverV2) func(*Options)

WithEndpointResolverV2 returns a functional option for setting the Client's EndpointResolverV2 option.

func WithSigV4SigningName added in v1.5.2 

func WithSigV4SigningName(name string) func(*Options)

WithSigV4SigningName applies an override to the authentication workflow to use the given signing name for SigV4-authenticated operations.

This is an advanced setting. The value here is FINAL, taking precedence over the resolved signing name from both auth scheme resolution and endpoint resolution.

func WithSigV4SigningRegion added in v1.5.2 

func WithSigV4SigningRegion(region string) func(*Options)

WithSigV4SigningRegion applies an override to the authentication workflow to use the given signing region for SigV4-authenticated operations.

This is an advanced setting. The value here is FINAL, taking precedence over the resolved signing region from both auth scheme resolution and endpoint resolution.

Types

type AuthResolverParameters added in v1.5.2 

type AuthResolverParameters struct {
	// The name of the operation being invoked.
	Operation string

	// The region in which the operation is being invoked.
	Region string
}

AuthResolverParameters contains the set of inputs necessary for auth scheme resolution.

type AuthSchemeResolver added in v1.5.2 

type AuthSchemeResolver interface {
	ResolveAuthSchemes(context.Context, *AuthResolverParameters) ([]*smithyauth.Option, error)
}

AuthSchemeResolver returns a set of possible authentication options for an operation.

type BatchIsAuthorizedInput added in v1.6.0 

type BatchIsAuthorizedInput struct {

	// Specifies the ID of the policy store. Policies in this policy store will be
	// used to make the authorization decisions for the input.
	//
	// This member is required.
	PolicyStoreId *string

	// An array of up to 30 requests that you want Verified Permissions to evaluate.
	//
	// This member is required.
	Requests []types.BatchIsAuthorizedInputItem

	// Specifies the list of resources and principals and their associated attributes
	// that Verified Permissions can examine when evaluating the policies. You can
	// include only principal and resource entities in this parameter; you can't
	// include actions. You must specify actions in the schema.
	Entities types.EntitiesDefinition
	// contains filtered or unexported fields
}

type BatchIsAuthorizedOutput added in v1.6.0 

type BatchIsAuthorizedOutput struct {

	// A series of Allow or Deny decisions for each request, and the policies that
	// produced them.
	//
	// This member is required.
	Results []types.BatchIsAuthorizedOutputItem

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type BatchIsAuthorizedWithTokenInput added in v1.13.0 

type BatchIsAuthorizedWithTokenInput struct {

	// Specifies the ID of the policy store. Policies in this policy store will be
	// used to make an authorization decision for the input.
	//
	// This member is required.
	PolicyStoreId *string

	// An array of up to 30 requests that you want Verified Permissions to evaluate.
	//
	// This member is required.
	Requests []types.BatchIsAuthorizedWithTokenInputItem

	// Specifies an access token for the principal that you want to authorize in each
	// request. This token is provided to you by the identity provider (IdP) associated
	// with the specified identity source. You must specify either an accessToken , an
	// identityToken , or both. Must be an access token. Verified Permissions returns
	// an error if the token_use claim in the submitted token isn't access .
	AccessToken *string

	// Specifies the list of resources and their associated attributes that Verified
	// Permissions can examine when evaluating the policies. You can't include
	// principals in this parameter, only resource and action entities. This parameter
	// can't include any entities of a type that matches the user or group entity types
	// that you defined in your identity source.
	//   - The BatchIsAuthorizedWithToken operation takes principal attributes from
	//   only the identityToken or accessToken passed to the operation.
	//   - For action entities, you can include only their Identifier and EntityType .
	Entities types.EntitiesDefinition

	// Specifies an identity (ID) token for the principal that you want to authorize
	// in each request. This token is provided to you by the identity provider (IdP)
	// associated with the specified identity source. You must specify either an
	// accessToken , an identityToken , or both. Must be an ID token. Verified
	// Permissions returns an error if the token_use claim in the submitted token
	// isn't id .
	IdentityToken *string
	// contains filtered or unexported fields
}

type BatchIsAuthorizedWithTokenOutput added in v1.13.0 

type BatchIsAuthorizedWithTokenOutput struct {

	// A series of Allow or Deny decisions for each request, and the policies that
	// produced them.
	//
	// This member is required.
	Results []types.BatchIsAuthorizedWithTokenOutputItem

	// The identifier of the principal in the ID or access token.
	Principal *types.EntityIdentifier

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client provides the API client to make operations call for Amazon Verified Permissions.

func New 

func New(options Options, optFns ...func(*Options)) *Client

New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

func NewFromConfig 

func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

NewFromConfig returns a new client from the provided config.

func (*Client) BatchIsAuthorized added in v1.6.0 

func (c *Client) BatchIsAuthorized(ctx context.Context, params *BatchIsAuthorizedInput, optFns ...func(*Options)) (*BatchIsAuthorizedOutput, error)

Makes a series of decisions about multiple authorization requests for one principal or resource. Each request contains the equivalent content of an IsAuthorized request: principal, action, resource, and context. Either the principal or the resource parameter must be identical across all requests. For example, Verified Permissions won't evaluate a pair of requests where bob views photo1 and alice views photo2 . Authorization of bob to view photo1 and photo2 , or bob and alice to view photo1 , are valid batches. The request is evaluated against all policies in the specified policy store that match the entities that you declare. The result of the decisions is a series of Allow or Deny responses, along with the IDs of the policies that produced each decision. The entities of a BatchIsAuthorized API request can contain up to 100 principals and up to 100 resources. The requests of a BatchIsAuthorized API request can contain up to 30 requests. The BatchIsAuthorized operation doesn't have its own IAM permission. To authorize this operation for Amazon Web Services principals, include the permission verifiedpermissions:IsAuthorized in their IAM policies.

func (*Client) BatchIsAuthorizedWithToken added in v1.13.0 

func (c *Client) BatchIsAuthorizedWithToken(ctx context.Context, params *BatchIsAuthorizedWithTokenInput, optFns ...func(*Options)) (*BatchIsAuthorizedWithTokenOutput, error)

Makes a series of decisions about multiple authorization requests for one token. The principal in this request comes from an external identity source in the form of an identity or access token, formatted as a JSON web token (JWT) (https://wikipedia.org/wiki/JSON_Web_Token) . The information in the parameters can also define additional context that Verified Permissions can include in the evaluations. The request is evaluated against all policies in the specified policy store that match the entities that you provide in the entities declaration and in the token. The result of the decisions is a series of Allow or Deny responses, along with the IDs of the policies that produced each decision. The entities of a BatchIsAuthorizedWithToken API request can contain up to 100 resources and up to 99 user groups. The requests of a BatchIsAuthorizedWithToken API request can contain up to 30 requests. The BatchIsAuthorizedWithToken operation doesn't have its own IAM permission. To authorize this operation for Amazon Web Services principals, include the permission verifiedpermissions:IsAuthorizedWithToken in their IAM policies.

func (*Client) CreateIdentitySource 

func (c *Client) CreateIdentitySource(ctx context.Context, params *CreateIdentitySourceInput, optFns ...func(*Options)) (*CreateIdentitySourceOutput, error)

Creates a reference to an Amazon Cognito user pool as an external identity provider (IdP). After you create an identity source, you can use the identities provided by the IdP as proxies for the principal in authorization queries that use the IsAuthorizedWithToken (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_IsAuthorizedWithToken.html) operation. These identities take the form of tokens that contain claims about the user, such as IDs, attributes and group memberships. Amazon Cognito provides both identity tokens and access tokens, and Verified Permissions can use either or both. Any combination of identity and access tokens results in the same Cedar principal. Verified Permissions automatically translates the information about the identities into the standard Cedar attributes that can be evaluated by your policies. Because the Amazon Cognito identity and access tokens can contain different information, the tokens you choose to use determine which principal attributes are available to access when evaluating Cedar policies. If you delete a Amazon Cognito user pool or user, tokens from that deleted pool or that deleted user continue to be usable until they expire. To reference a user from this identity source in your Cedar policies, use the following syntax. IdentityType::"<CognitoUserPoolIdentifier>|<CognitoClientId> Where IdentityType is the string that you provide to the PrincipalEntityType parameter for this operation. The CognitoUserPoolId and CognitoClientId are defined by the Amazon Cognito user pool. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) CreatePolicy 

func (c *Client) CreatePolicy(ctx context.Context, params *CreatePolicyInput, optFns ...func(*Options)) (*CreatePolicyOutput, error)

Creates a Cedar policy and saves it in the specified policy store. You can create either a static policy or a policy linked to a policy template.

  • To create a static policy, provide the Cedar policy text in the StaticPolicy section of the PolicyDefinition .
  • To create a policy that is dynamically linked to a policy template, specify the policy template ID and the principal and resource to associate with this policy in the templateLinked section of the PolicyDefinition . If the policy template is ever updated, any policies linked to the policy template automatically use the updated template.

Creating a policy causes it to be validated against the schema in the policy store. If the policy doesn't pass validation, the operation fails and the policy isn't stored. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) CreatePolicyStore 

func (c *Client) CreatePolicyStore(ctx context.Context, params *CreatePolicyStoreInput, optFns ...func(*Options)) (*CreatePolicyStoreOutput, error)

Creates a policy store. A policy store is a container for policy resources. Although Cedar supports multiple namespaces (https://docs.cedarpolicy.com/schema/schema.html#namespace) , Verified Permissions currently supports only one namespace per policy store. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) CreatePolicyTemplate 

func (c *Client) CreatePolicyTemplate(ctx context.Context, params *CreatePolicyTemplateInput, optFns ...func(*Options)) (*CreatePolicyTemplateOutput, error)

Creates a policy template. A template can use placeholders for the principal and resource. A template must be instantiated into a policy by associating it with specific principals and resources to use for the placeholders. That instantiated policy can then be considered in authorization decisions. The instantiated policy works identically to any other policy, except that it is dynamically linked to the template. If the template changes, then any policies that are linked to that template are immediately updated as well. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) DeleteIdentitySource 

func (c *Client) DeleteIdentitySource(ctx context.Context, params *DeleteIdentitySourceInput, optFns ...func(*Options)) (*DeleteIdentitySourceOutput, error)

Deletes an identity source that references an identity provider (IdP) such as Amazon Cognito. After you delete the identity source, you can no longer use tokens for identities from that identity source to represent principals in authorization queries made using IsAuthorizedWithToken (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_IsAuthorizedWithToken.html) . operations.

func (*Client) DeletePolicy 

func (c *Client) DeletePolicy(ctx context.Context, params *DeletePolicyInput, optFns ...func(*Options)) (*DeletePolicyOutput, error)

Deletes the specified policy from the policy store. This operation is idempotent; if you specify a policy that doesn't exist, the request response returns a successful HTTP 200 status code.

func (*Client) DeletePolicyStore 

func (c *Client) DeletePolicyStore(ctx context.Context, params *DeletePolicyStoreInput, optFns ...func(*Options)) (*DeletePolicyStoreOutput, error)

Deletes the specified policy store. This operation is idempotent. If you specify a policy store that does not exist, the request response will still return a successful HTTP 200 status code.

func (*Client) DeletePolicyTemplate 

func (c *Client) DeletePolicyTemplate(ctx context.Context, params *DeletePolicyTemplateInput, optFns ...func(*Options)) (*DeletePolicyTemplateOutput, error)

Deletes the specified policy template from the policy store. This operation also deletes any policies that were created from the specified policy template. Those policies are immediately removed from all future API responses, and are asynchronously deleted from the policy store.

func (*Client) GetIdentitySource 

func (c *Client) GetIdentitySource(ctx context.Context, params *GetIdentitySourceInput, optFns ...func(*Options)) (*GetIdentitySourceOutput, error)

Retrieves the details about the specified identity source.

func (*Client) GetPolicy 

func (c *Client) GetPolicy(ctx context.Context, params *GetPolicyInput, optFns ...func(*Options)) (*GetPolicyOutput, error)

Retrieves information about the specified policy.

func (*Client) GetPolicyStore 

func (c *Client) GetPolicyStore(ctx context.Context, params *GetPolicyStoreInput, optFns ...func(*Options)) (*GetPolicyStoreOutput, error)

Retrieves details about a policy store.

func (*Client) GetPolicyTemplate 

func (c *Client) GetPolicyTemplate(ctx context.Context, params *GetPolicyTemplateInput, optFns ...func(*Options)) (*GetPolicyTemplateOutput, error)

Retrieve the details for the specified policy template in the specified policy store.

func (*Client) GetSchema 

func (c *Client) GetSchema(ctx context.Context, params *GetSchemaInput, optFns ...func(*Options)) (*GetSchemaOutput, error)

Retrieve the details for the specified schema in the specified policy store.

func (*Client) IsAuthorized 

func (c *Client) IsAuthorized(ctx context.Context, params *IsAuthorizedInput, optFns ...func(*Options)) (*IsAuthorizedOutput, error)

Makes an authorization decision about a service request described in the parameters. The information in the parameters can also define additional context that Verified Permissions can include in the evaluation. The request is evaluated against all matching policies in the specified policy store. The result of the decision is either Allow or Deny , along with a list of the policies that resulted in the decision.

func (*Client) IsAuthorizedWithToken 

func (c *Client) IsAuthorizedWithToken(ctx context.Context, params *IsAuthorizedWithTokenInput, optFns ...func(*Options)) (*IsAuthorizedWithTokenOutput, error)

Makes an authorization decision about a service request described in the parameters. The principal in this request comes from an external identity source in the form of an identity token formatted as a JSON web token (JWT) (https://wikipedia.org/wiki/JSON_Web_Token) . The information in the parameters can also define additional context that Verified Permissions can include in the evaluation. The request is evaluated against all matching policies in the specified policy store. The result of the decision is either Allow or Deny , along with a list of the policies that resulted in the decision. At this time, Verified Permissions accepts tokens from only Amazon Cognito. Verified Permissions validates each token that is specified in a request by checking its expiration date and its signature. If you delete a Amazon Cognito user pool or user, tokens from that deleted pool or that deleted user continue to be usable until they expire.

func (*Client) ListIdentitySources 

func (c *Client) ListIdentitySources(ctx context.Context, params *ListIdentitySourcesInput, optFns ...func(*Options)) (*ListIdentitySourcesOutput, error)

Returns a paginated list of all of the identity sources defined in the specified policy store.

func (*Client) ListPolicies 

func (c *Client) ListPolicies(ctx context.Context, params *ListPoliciesInput, optFns ...func(*Options)) (*ListPoliciesOutput, error)

Returns a paginated list of all policies stored in the specified policy store.

func (*Client) ListPolicyStores 

func (c *Client) ListPolicyStores(ctx context.Context, params *ListPolicyStoresInput, optFns ...func(*Options)) (*ListPolicyStoresOutput, error)

Returns a paginated list of all policy stores in the calling Amazon Web Services account.

func (*Client) ListPolicyTemplates 

func (c *Client) ListPolicyTemplates(ctx context.Context, params *ListPolicyTemplatesInput, optFns ...func(*Options)) (*ListPolicyTemplatesOutput, error)

Returns a paginated list of all policy templates in the specified policy store.

func (*Client) Options added in v1.7.0 

func (c *Client) Options() Options

Options returns a copy of the client configuration.

Callers SHOULD NOT perform mutations on any inner structures within client config. Config overrides should instead be made on a per-operation basis through functional options.

func (*Client) PutSchema 

func (c *Client) PutSchema(ctx context.Context, params *PutSchemaInput, optFns ...func(*Options)) (*PutSchemaOutput, error)

Creates or updates the policy schema in the specified policy store. The schema is used to validate any Cedar policies and policy templates submitted to the policy store. Any changes to the schema validate only policies and templates submitted after the schema change. Existing policies and templates are not re-evaluated against the changed schema. If you later update a policy, then it is evaluated against the new schema at that time. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) UpdateIdentitySource 

func (c *Client) UpdateIdentitySource(ctx context.Context, params *UpdateIdentitySourceInput, optFns ...func(*Options)) (*UpdateIdentitySourceOutput, error)

Updates the specified identity source to use a new identity provider (IdP) source, or to change the mapping of identities from the IdP to a different principal entity type. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) UpdatePolicy 

func (c *Client) UpdatePolicy(ctx context.Context, params *UpdatePolicyInput, optFns ...func(*Options)) (*UpdatePolicyOutput, error)

Modifies a Cedar static policy in the specified policy store. You can change only certain elements of the UpdatePolicyDefinition (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyInput.html#amazonverifiedpermissions-UpdatePolicy-request-UpdatePolicyDefinition) parameter. You can directly update only static policies. To change a template-linked policy, you must update the template instead, using UpdatePolicyTemplate (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyTemplate.html) .

  • If policy validation is enabled in the policy store, then updating a static policy causes Verified Permissions to validate the policy against the schema in the policy store. If the updated static policy doesn't pass validation, the operation fails and the update isn't stored.
  • When you edit a static policy, you can change only certain elements of a static policy:
  • The action referenced by the policy.
  • A condition clause, such as when and unless. You can't change these elements of a static policy:
  • Changing a policy from a static policy to a template-linked policy.
  • Changing the effect of a static policy from permit or forbid.
  • The principal referenced by a static policy.
  • The resource referenced by a static policy.
  • To update a template-linked policy, you must update the template instead.

Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) UpdatePolicyStore 

func (c *Client) UpdatePolicyStore(ctx context.Context, params *UpdatePolicyStoreInput, optFns ...func(*Options)) (*UpdatePolicyStoreOutput, error)

Modifies the validation setting for a policy store. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

func (*Client) UpdatePolicyTemplate 

func (c *Client) UpdatePolicyTemplate(ctx context.Context, params *UpdatePolicyTemplateInput, optFns ...func(*Options)) (*UpdatePolicyTemplateOutput, error)

Updates the specified policy template. You can update only the description and the some elements of the policyBody (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyTemplate.html#amazonverifiedpermissions-UpdatePolicyTemplate-request-policyBody) . Changes you make to the policy template content are immediately (within the constraints of eventual consistency) reflected in authorization decisions that involve all template-linked policies instantiated from this template. Verified Permissions is eventually consistent (https://wikipedia.org/wiki/Eventual_consistency) . It can take a few seconds for a new or changed element to propagate through the service and be visible in the results of other Verified Permissions operations.

type CreateIdentitySourceInput 

type CreateIdentitySourceInput struct {

	// Specifies the details required to communicate with the identity provider (IdP)
	// associated with this identity source. At this time, the only valid member of
	// this structure is a Amazon Cognito user pool configuration. You must specify a
	// UserPoolArn , and optionally, a ClientId .
	//
	// This member is required.
	Configuration types.Configuration

	// Specifies the ID of the policy store in which you want to store this identity
	// source. Only policies and requests made using this policy store can reference
	// identities from the identity provider configured in the new identity source.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies a unique, case-sensitive ID that you provide to ensure the
	// idempotency of the request. This lets you safely retry the request without
	// accidentally performing the same operation a second time. Passing the same value
	// to a later call to an operation requires that you also pass the same value for
	// all other parameters. We recommend that you use a UUID type of value. (https://wikipedia.org/wiki/Universally_unique_identifier)
	// . If you don't provide this value, then Amazon Web Services generates a random
	// one for you. If you retry the operation with the same ClientToken , but with
	// different parameters, the retry fails with an ConflictException error. Verified
	// Permissions recognizes a ClientToken for eight hours. After eight hours, the
	// next request with the same parameters performs the operation again regardless of
	// the value of ClientToken .
	ClientToken *string

	// Specifies the namespace and data type of the principals generated for
	// identities authenticated by the new identity source.
	PrincipalEntityType *string
	// contains filtered or unexported fields
}

type CreateIdentitySourceOutput 

type CreateIdentitySourceOutput struct {

	// The date and time the identity source was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The unique ID of the new identity source.
	//
	// This member is required.
	IdentitySourceId *string

	// The date and time the identity source was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the identity source.
	//
	// This member is required.
	PolicyStoreId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreatePolicyInput 

type CreatePolicyInput struct {

	// A structure that specifies the policy type and content to use for the new
	// policy. You must include either a static or a templateLinked element. The policy
	// content must be written in the Cedar policy language.
	//
	// This member is required.
	Definition types.PolicyDefinition

	// Specifies the PolicyStoreId of the policy store you want to store the policy in.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies a unique, case-sensitive ID that you provide to ensure the
	// idempotency of the request. This lets you safely retry the request without
	// accidentally performing the same operation a second time. Passing the same value
	// to a later call to an operation requires that you also pass the same value for
	// all other parameters. We recommend that you use a UUID type of value. (https://wikipedia.org/wiki/Universally_unique_identifier)
	// . If you don't provide this value, then Amazon Web Services generates a random
	// one for you. If you retry the operation with the same ClientToken , but with
	// different parameters, the retry fails with an ConflictException error. Verified
	// Permissions recognizes a ClientToken for eight hours. After eight hours, the
	// next request with the same parameters performs the operation again regardless of
	// the value of ClientToken .
	ClientToken *string
	// contains filtered or unexported fields
}

type CreatePolicyOutput 

type CreatePolicyOutput struct {

	// The date and time the policy was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time the policy was last updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The unique ID of the new policy.
	//
	// This member is required.
	PolicyId *string

	// The ID of the policy store that contains the new policy.
	//
	// This member is required.
	PolicyStoreId *string

	// The policy type of the new policy.
	//
	// This member is required.
	PolicyType types.PolicyType

	// The principal specified in the new policy's scope. This response element isn't
	// present when principal isn't specified in the policy content.
	Principal *types.EntityIdentifier

	// The resource specified in the new policy's scope. This response element isn't
	// present when the resource isn't specified in the policy content.
	Resource *types.EntityIdentifier

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreatePolicyStoreInput 

type CreatePolicyStoreInput struct {

	// Specifies the validation setting for this policy store. Currently, the only
	// valid and required value is Mode . We recommend that you turn on STRICT mode
	// only after you define a schema. If a schema doesn't exist, then STRICT mode
	// causes any policy to fail validation, and Verified Permissions rejects the
	// policy. You can turn off validation by using the UpdatePolicyStore (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyStore)
	// . Then, when you have a schema defined, use UpdatePolicyStore (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicyStore)
	// again to turn validation back on.
	//
	// This member is required.
	ValidationSettings *types.ValidationSettings

	// Specifies a unique, case-sensitive ID that you provide to ensure the
	// idempotency of the request. This lets you safely retry the request without
	// accidentally performing the same operation a second time. Passing the same value
	// to a later call to an operation requires that you also pass the same value for
	// all other parameters. We recommend that you use a UUID type of value. (https://wikipedia.org/wiki/Universally_unique_identifier)
	// . If you don't provide this value, then Amazon Web Services generates a random
	// one for you. If you retry the operation with the same ClientToken , but with
	// different parameters, the retry fails with an ConflictException error. Verified
	// Permissions recognizes a ClientToken for eight hours. After eight hours, the
	// next request with the same parameters performs the operation again regardless of
	// the value of ClientToken .
	ClientToken *string

	// Descriptive text that you can provide to help with identification of the
	// current policy store.
	Description *string
	// contains filtered or unexported fields
}

type CreatePolicyStoreOutput 

type CreatePolicyStoreOutput struct {

	// The Amazon Resource Name (ARN) of the new policy store.
	//
	// This member is required.
	Arn *string

	// The date and time the policy store was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time the policy store was last updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The unique ID of the new policy store.
	//
	// This member is required.
	PolicyStoreId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreatePolicyTemplateInput 

type CreatePolicyTemplateInput struct {

	// The ID of the policy store in which to create the policy template.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the content that you want to use for the new policy template, written
	// in the Cedar policy language.
	//
	// This member is required.
	Statement *string

	// Specifies a unique, case-sensitive ID that you provide to ensure the
	// idempotency of the request. This lets you safely retry the request without
	// accidentally performing the same operation a second time. Passing the same value
	// to a later call to an operation requires that you also pass the same value for
	// all other parameters. We recommend that you use a UUID type of value. (https://wikipedia.org/wiki/Universally_unique_identifier)
	// . If you don't provide this value, then Amazon Web Services generates a random
	// one for you. If you retry the operation with the same ClientToken , but with
	// different parameters, the retry fails with an ConflictException error. Verified
	// Permissions recognizes a ClientToken for eight hours. After eight hours, the
	// next request with the same parameters performs the operation again regardless of
	// the value of ClientToken .
	ClientToken *string

	// Specifies a description for the policy template.
	Description *string
	// contains filtered or unexported fields
}

type CreatePolicyTemplateOutput 

type CreatePolicyTemplateOutput struct {

	// The date and time the policy template was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time the policy template was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the policy template.
	//
	// This member is required.
	PolicyStoreId *string

	// The unique ID of the new policy template.
	//
	// This member is required.
	PolicyTemplateId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteIdentitySourceInput 

type DeleteIdentitySourceInput struct {

	// Specifies the ID of the identity source that you want to delete.
	//
	// This member is required.
	IdentitySourceId *string

	// Specifies the ID of the policy store that contains the identity source that you
	// want to delete.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type DeleteIdentitySourceOutput 

type DeleteIdentitySourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeletePolicyInput 

type DeletePolicyInput struct {

	// Specifies the ID of the policy that you want to delete.
	//
	// This member is required.
	PolicyId *string

	// Specifies the ID of the policy store that contains the policy that you want to
	// delete.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type DeletePolicyOutput 

type DeletePolicyOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeletePolicyStoreInput 

type DeletePolicyStoreInput struct {

	// Specifies the ID of the policy store that you want to delete.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type DeletePolicyStoreOutput 

type DeletePolicyStoreOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeletePolicyTemplateInput 

type DeletePolicyTemplateInput struct {

	// Specifies the ID of the policy store that contains the policy template that you
	// want to delete.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the ID of the policy template that you want to delete.
	//
	// This member is required.
	PolicyTemplateId *string
	// contains filtered or unexported fields
}

type DeletePolicyTemplateOutput 

type DeletePolicyTemplateOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type EndpointParameters added in v1.1.0 

type EndpointParameters struct {
	// The AWS region used to dispatch the request.
	//
	// Parameter is
	// required.
	//
	// AWS::Region
	Region *string

	// When true, use the dual-stack endpoint. If the configured endpoint does not
	// support dual-stack, dispatching the request MAY return an error.
	//
	// Defaults to
	// false if no value is provided.
	//
	// AWS::UseDualStack
	UseDualStack *bool

	// When true, send this request to the FIPS-compliant regional endpoint. If the
	// configured endpoint does not have a FIPS compliant endpoint, dispatching the
	// request will return an error.
	//
	// Defaults to false if no value is
	// provided.
	//
	// AWS::UseFIPS
	UseFIPS *bool

	// Override the endpoint used to send this request
	//
	// Parameter is
	// required.
	//
	// SDK::Endpoint
	Endpoint *string
}

EndpointParameters provides the parameters that influence how endpoints are resolved.

func (EndpointParameters) ValidateRequired added in v1.1.0 

func (p EndpointParameters) ValidateRequired() error

ValidateRequired validates required parameters are set.

func (EndpointParameters) WithDefaults added in v1.1.0 

func (p EndpointParameters) WithDefaults() EndpointParameters

WithDefaults returns a shallow copy of EndpointParameterswith default values applied to members where applicable.

type EndpointResolver 

type EndpointResolver interface {
	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}

EndpointResolver interface for resolving service endpoints.

func EndpointResolverFromURL 

func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

type EndpointResolverFunc 

type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

func (EndpointResolverFunc) ResolveEndpoint 

func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

type EndpointResolverOptions 

type EndpointResolverOptions = internalendpoints.Options

EndpointResolverOptions is the service endpoint resolver options

type EndpointResolverV2 added in v1.1.0 

type EndpointResolverV2 interface {
	// ResolveEndpoint attempts to resolve the endpoint with the provided options,
	// returning the endpoint if found. Otherwise an error is returned.
	ResolveEndpoint(ctx context.Context, params EndpointParameters) (
		smithyendpoints.Endpoint, error,
	)
}

EndpointResolverV2 provides the interface for resolving service endpoints.

func NewDefaultEndpointResolverV2 added in v1.1.0 

func NewDefaultEndpointResolverV2() EndpointResolverV2

type GetIdentitySourceInput 

type GetIdentitySourceInput struct {

	// Specifies the ID of the identity source you want information about.
	//
	// This member is required.
	IdentitySourceId *string

	// Specifies the ID of the policy store that contains the identity source you want
	// information about.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type GetIdentitySourceOutput 

type GetIdentitySourceOutput struct {

	// The date and time that the identity source was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The ID of the identity source.
	//
	// This member is required.
	IdentitySourceId *string

	// The date and time that the identity source was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the identity source.
	//
	// This member is required.
	PolicyStoreId *string

	// The data type of principals generated for identities authenticated by this
	// identity source.
	//
	// This member is required.
	PrincipalEntityType *string

	// Contains configuration information about an identity source.
	Configuration types.ConfigurationDetail

	// A structure that describes the configuration of the identity source.
	//
	// Deprecated: This attribute has been replaced by
	// configuration.cognitoUserPoolConfiguration
	Details *types.IdentitySourceDetails

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetPolicyInput 

type GetPolicyInput struct {

	// Specifies the ID of the policy you want information about.
	//
	// This member is required.
	PolicyId *string

	// Specifies the ID of the policy store that contains the policy that you want
	// information about.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type GetPolicyOutput 

type GetPolicyOutput struct {

	// The date and time that the policy was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The definition of the requested policy.
	//
	// This member is required.
	Definition types.PolicyDefinitionDetail

	// The date and time that the policy was last updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The unique ID of the policy that you want information about.
	//
	// This member is required.
	PolicyId *string

	// The ID of the policy store that contains the policy that you want information
	// about.
	//
	// This member is required.
	PolicyStoreId *string

	// The type of the policy.
	//
	// This member is required.
	PolicyType types.PolicyType

	// The principal specified in the policy's scope. This element isn't included in
	// the response when Principal isn't present in the policy content.
	Principal *types.EntityIdentifier

	// The resource specified in the policy's scope. This element isn't included in
	// the response when Resource isn't present in the policy content.
	Resource *types.EntityIdentifier

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetPolicyStoreInput 

type GetPolicyStoreInput struct {

	// Specifies the ID of the policy store that you want information about.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type GetPolicyStoreOutput 

type GetPolicyStoreOutput struct {

	// The Amazon Resource Name (ARN) of the policy store.
	//
	// This member is required.
	Arn *string

	// The date and time that the policy store was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the policy store was last updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store;
	//
	// This member is required.
	PolicyStoreId *string

	// The current validation settings for the policy store.
	//
	// This member is required.
	ValidationSettings *types.ValidationSettings

	// Descriptive text that you can provide to help with identification of the
	// current policy store.
	Description *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetPolicyTemplateInput 

type GetPolicyTemplateInput struct {

	// Specifies the ID of the policy store that contains the policy template that you
	// want information about.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the ID of the policy template that you want information about.
	//
	// This member is required.
	PolicyTemplateId *string
	// contains filtered or unexported fields
}

type GetPolicyTemplateOutput 

type GetPolicyTemplateOutput struct {

	// The date and time that the policy template was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the policy template was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the policy template.
	//
	// This member is required.
	PolicyStoreId *string

	// The ID of the policy template.
	//
	// This member is required.
	PolicyTemplateId *string

	// The content of the body of the policy template written in the Cedar policy
	// language.
	//
	// This member is required.
	Statement *string

	// The description of the policy template.
	Description *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetSchemaInput 

type GetSchemaInput struct {

	// Specifies the ID of the policy store that contains the schema.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type GetSchemaOutput 

type GetSchemaOutput struct {

	// The date and time that the schema was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the schema was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the schema.
	//
	// This member is required.
	PolicyStoreId *string

	// The body of the schema, written in Cedar schema JSON.
	//
	// This member is required.
	Schema *string

	// The namespaces of the entities referenced by this schema.
	Namespaces []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type HTTPClient 

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}

type IdempotencyTokenProvider 

type IdempotencyTokenProvider interface {
	GetIdempotencyToken() (string, error)
}

IdempotencyTokenProvider interface for providing idempotency token

type IsAuthorizedInput 

type IsAuthorizedInput struct {

	// Specifies the ID of the policy store. Policies in this policy store will be
	// used to make an authorization decision for the input.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the requested action to be authorized. For example, is the principal
	// authorized to perform this action on the resource?
	Action *types.ActionIdentifier

	// Specifies additional context that can be used to make more granular
	// authorization decisions.
	Context types.ContextDefinition

	// Specifies the list of resources and principals and their associated attributes
	// that Verified Permissions can examine when evaluating the policies. You can
	// include only principal and resource entities in this parameter; you can't
	// include actions. You must specify actions in the schema.
	Entities types.EntitiesDefinition

	// Specifies the principal for which the authorization decision is to be made.
	Principal *types.EntityIdentifier

	// Specifies the resource for which the authorization decision is to be made.
	Resource *types.EntityIdentifier
	// contains filtered or unexported fields
}

type IsAuthorizedOutput 

type IsAuthorizedOutput struct {

	// An authorization decision that indicates if the authorization request should be
	// allowed or denied.
	//
	// This member is required.
	Decision types.Decision

	// The list of determining policies used to make the authorization decision. For
	// example, if there are two matching policies, where one is a forbid and the other
	// is a permit, then the forbid policy will be the determining policy. In the case
	// of multiple matching permit policies then there would be multiple determining
	// policies. In the case that no policies match, and hence the response is DENY,
	// there would be no determining policies.
	//
	// This member is required.
	DeterminingPolicies []types.DeterminingPolicyItem

	// Errors that occurred while making an authorization decision, for example, a
	// policy references an Entity or entity Attribute that does not exist in the
	// slice.
	//
	// This member is required.
	Errors []types.EvaluationErrorItem

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type IsAuthorizedWithTokenInput 

type IsAuthorizedWithTokenInput struct {

	// Specifies the ID of the policy store. Policies in this policy store will be
	// used to make an authorization decision for the input.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies an access token for the principal to be authorized. This token is
	// provided to you by the identity provider (IdP) associated with the specified
	// identity source. You must specify either an accessToken , an identityToken , or
	// both. Must be an access token. Verified Permissions returns an error if the
	// token_use claim in the submitted token isn't access .
	AccessToken *string

	// Specifies the requested action to be authorized. Is the specified principal
	// authorized to perform this action on the specified resource.
	Action *types.ActionIdentifier

	// Specifies additional context that can be used to make more granular
	// authorization decisions.
	Context types.ContextDefinition

	// Specifies the list of resources and their associated attributes that Verified
	// Permissions can examine when evaluating the policies. You can't include
	// principals in this parameter, only resource and action entities. This parameter
	// can't include any entities of a type that matches the user or group entity types
	// that you defined in your identity source.
	//   - The IsAuthorizedWithToken operation takes principal attributes from only the
	//   identityToken or accessToken passed to the operation.
	//   - For action entities, you can include only their Identifier and EntityType .
	Entities types.EntitiesDefinition

	// Specifies an identity token for the principal to be authorized. This token is
	// provided to you by the identity provider (IdP) associated with the specified
	// identity source. You must specify either an accessToken , an identityToken , or
	// both. Must be an ID token. Verified Permissions returns an error if the
	// token_use claim in the submitted token isn't id .
	IdentityToken *string

	// Specifies the resource for which the authorization decision is made. For
	// example, is the principal allowed to perform the action on the resource?
	Resource *types.EntityIdentifier
	// contains filtered or unexported fields
}

type IsAuthorizedWithTokenOutput 

type IsAuthorizedWithTokenOutput struct {

	// An authorization decision that indicates if the authorization request should be
	// allowed or denied.
	//
	// This member is required.
	Decision types.Decision

	// The list of determining policies used to make the authorization decision. For
	// example, if there are multiple matching policies, where at least one is a forbid
	// policy, then because forbid always overrides permit the forbid policies are the
	// determining policies. If all matching policies are permit policies, then those
	// policies are the determining policies. When no policies match and the response
	// is the default DENY, there are no determining policies.
	//
	// This member is required.
	DeterminingPolicies []types.DeterminingPolicyItem

	// Errors that occurred while making an authorization decision. For example, a
	// policy references an entity or entity attribute that does not exist in the
	// slice.
	//
	// This member is required.
	Errors []types.EvaluationErrorItem

	// The identifier of the principal in the ID or access token.
	Principal *types.EntityIdentifier

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListIdentitySourcesAPIClient 

type ListIdentitySourcesAPIClient interface {
	ListIdentitySources(context.Context, *ListIdentitySourcesInput, ...func(*Options)) (*ListIdentitySourcesOutput, error)
}

ListIdentitySourcesAPIClient is a client that implements the ListIdentitySources operation.

type ListIdentitySourcesInput 

type ListIdentitySourcesInput struct {

	// Specifies the ID of the policy store that contains the identity sources that
	// you want to list.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies characteristics of an identity source that you can use to limit the
	// output to matching identity sources.
	Filters []types.IdentitySourceFilter

	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 identity sources per
	// response. You can specify a maximum of 200 identity sources per response.
	MaxResults *int32

	// Specifies that you want to receive the next page of results. Valid only if you
	// received a NextToken response in the previous request. If you did, it indicates
	// that more output is available. Set this parameter to the value provided by the
	// previous call's NextToken response to request the next page of results.
	NextToken *string
	// contains filtered or unexported fields
}

type ListIdentitySourcesOutput 

type ListIdentitySourcesOutput struct {

	// The list of identity sources stored in the specified policy store.
	//
	// This member is required.
	IdentitySources []types.IdentitySourceItem

	// If present, this value indicates that more output is available than is included
	// in the current response. Use this value in the NextToken request parameter in a
	// subsequent call to the operation to get the next part of the output. You should
	// repeat this until the NextToken response element comes back as null . This
	// indicates that this is the last page of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListIdentitySourcesPaginator 

type ListIdentitySourcesPaginator struct {
	// contains filtered or unexported fields
}

ListIdentitySourcesPaginator is a paginator for ListIdentitySources

func NewListIdentitySourcesPaginator 

func NewListIdentitySourcesPaginator(client ListIdentitySourcesAPIClient, params *ListIdentitySourcesInput, optFns ...func(*ListIdentitySourcesPaginatorOptions)) *ListIdentitySourcesPaginator

NewListIdentitySourcesPaginator returns a new ListIdentitySourcesPaginator

func (*ListIdentitySourcesPaginator) HasMorePages 

func (p *ListIdentitySourcesPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListIdentitySourcesPaginator) NextPage 

func (p *ListIdentitySourcesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListIdentitySourcesOutput, error)

NextPage retrieves the next ListIdentitySources page.

type ListIdentitySourcesPaginatorOptions 

type ListIdentitySourcesPaginatorOptions struct {
	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 identity sources per
	// response. You can specify a maximum of 200 identity sources per response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListIdentitySourcesPaginatorOptions is the paginator options for ListIdentitySources

type ListPoliciesAPIClient 

type ListPoliciesAPIClient interface {
	ListPolicies(context.Context, *ListPoliciesInput, ...func(*Options)) (*ListPoliciesOutput, error)
}

ListPoliciesAPIClient is a client that implements the ListPolicies operation.

type ListPoliciesInput 

type ListPoliciesInput struct {

	// Specifies the ID of the policy store you want to list policies from.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies a filter that limits the response to only policies that match the
	// specified criteria. For example, you list only the policies that reference a
	// specified principal.
	Filter *types.PolicyFilter

	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 policies per response.
	// You can specify a maximum of 50 policies per response.
	MaxResults *int32

	// Specifies that you want to receive the next page of results. Valid only if you
	// received a NextToken response in the previous request. If you did, it indicates
	// that more output is available. Set this parameter to the value provided by the
	// previous call's NextToken response to request the next page of results.
	NextToken *string
	// contains filtered or unexported fields
}

type ListPoliciesOutput 

type ListPoliciesOutput struct {

	// Lists all policies that are available in the specified policy store.
	//
	// This member is required.
	Policies []types.PolicyItem

	// If present, this value indicates that more output is available than is included
	// in the current response. Use this value in the NextToken request parameter in a
	// subsequent call to the operation to get the next part of the output. You should
	// repeat this until the NextToken response element comes back as null . This
	// indicates that this is the last page of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListPoliciesPaginator 

type ListPoliciesPaginator struct {
	// contains filtered or unexported fields
}

ListPoliciesPaginator is a paginator for ListPolicies

func NewListPoliciesPaginator 

func NewListPoliciesPaginator(client ListPoliciesAPIClient, params *ListPoliciesInput, optFns ...func(*ListPoliciesPaginatorOptions)) *ListPoliciesPaginator

NewListPoliciesPaginator returns a new ListPoliciesPaginator

func (*ListPoliciesPaginator) HasMorePages 

func (p *ListPoliciesPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListPoliciesPaginator) NextPage 

func (p *ListPoliciesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPoliciesOutput, error)

NextPage retrieves the next ListPolicies page.

type ListPoliciesPaginatorOptions 

type ListPoliciesPaginatorOptions struct {
	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 policies per response.
	// You can specify a maximum of 50 policies per response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListPoliciesPaginatorOptions is the paginator options for ListPolicies

type ListPolicyStoresAPIClient 

type ListPolicyStoresAPIClient interface {
	ListPolicyStores(context.Context, *ListPolicyStoresInput, ...func(*Options)) (*ListPolicyStoresOutput, error)
}

ListPolicyStoresAPIClient is a client that implements the ListPolicyStores operation.

type ListPolicyStoresInput 

type ListPolicyStoresInput struct {

	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 policy stores per
	// response. You can specify a maximum of 50 policy stores per response.
	MaxResults *int32

	// Specifies that you want to receive the next page of results. Valid only if you
	// received a NextToken response in the previous request. If you did, it indicates
	// that more output is available. Set this parameter to the value provided by the
	// previous call's NextToken response to request the next page of results.
	NextToken *string
	// contains filtered or unexported fields
}

type ListPolicyStoresOutput 

type ListPolicyStoresOutput struct {

	// The list of policy stores in the account.
	//
	// This member is required.
	PolicyStores []types.PolicyStoreItem

	// If present, this value indicates that more output is available than is included
	// in the current response. Use this value in the NextToken request parameter in a
	// subsequent call to the operation to get the next part of the output. You should
	// repeat this until the NextToken response element comes back as null . This
	// indicates that this is the last page of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListPolicyStoresPaginator 

type ListPolicyStoresPaginator struct {
	// contains filtered or unexported fields
}

ListPolicyStoresPaginator is a paginator for ListPolicyStores

func NewListPolicyStoresPaginator 

func NewListPolicyStoresPaginator(client ListPolicyStoresAPIClient, params *ListPolicyStoresInput, optFns ...func(*ListPolicyStoresPaginatorOptions)) *ListPolicyStoresPaginator

NewListPolicyStoresPaginator returns a new ListPolicyStoresPaginator

func (*ListPolicyStoresPaginator) HasMorePages 

func (p *ListPolicyStoresPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListPolicyStoresPaginator) NextPage 

func (p *ListPolicyStoresPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPolicyStoresOutput, error)

NextPage retrieves the next ListPolicyStores page.

type ListPolicyStoresPaginatorOptions 

type ListPolicyStoresPaginatorOptions struct {
	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 policy stores per
	// response. You can specify a maximum of 50 policy stores per response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListPolicyStoresPaginatorOptions is the paginator options for ListPolicyStores

type ListPolicyTemplatesAPIClient 

type ListPolicyTemplatesAPIClient interface {
	ListPolicyTemplates(context.Context, *ListPolicyTemplatesInput, ...func(*Options)) (*ListPolicyTemplatesOutput, error)
}

ListPolicyTemplatesAPIClient is a client that implements the ListPolicyTemplates operation.

type ListPolicyTemplatesInput 

type ListPolicyTemplatesInput struct {

	// Specifies the ID of the policy store that contains the policy templates you
	// want to list.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 policy templates per
	// response. You can specify a maximum of 50 policy templates per response.
	MaxResults *int32

	// Specifies that you want to receive the next page of results. Valid only if you
	// received a NextToken response in the previous request. If you did, it indicates
	// that more output is available. Set this parameter to the value provided by the
	// previous call's NextToken response to request the next page of results.
	NextToken *string
	// contains filtered or unexported fields
}

type ListPolicyTemplatesOutput 

type ListPolicyTemplatesOutput struct {

	// The list of the policy templates in the specified policy store.
	//
	// This member is required.
	PolicyTemplates []types.PolicyTemplateItem

	// If present, this value indicates that more output is available than is included
	// in the current response. Use this value in the NextToken request parameter in a
	// subsequent call to the operation to get the next part of the output. You should
	// repeat this until the NextToken response element comes back as null . This
	// indicates that this is the last page of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListPolicyTemplatesPaginator 

type ListPolicyTemplatesPaginator struct {
	// contains filtered or unexported fields
}

ListPolicyTemplatesPaginator is a paginator for ListPolicyTemplates

func NewListPolicyTemplatesPaginator 

func NewListPolicyTemplatesPaginator(client ListPolicyTemplatesAPIClient, params *ListPolicyTemplatesInput, optFns ...func(*ListPolicyTemplatesPaginatorOptions)) *ListPolicyTemplatesPaginator

NewListPolicyTemplatesPaginator returns a new ListPolicyTemplatesPaginator

func (*ListPolicyTemplatesPaginator) HasMorePages 

func (p *ListPolicyTemplatesPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListPolicyTemplatesPaginator) NextPage 

func (p *ListPolicyTemplatesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPolicyTemplatesOutput, error)

NextPage retrieves the next ListPolicyTemplates page.

type ListPolicyTemplatesPaginatorOptions 

type ListPolicyTemplatesPaginatorOptions struct {
	// Specifies the total number of results that you want included in each response.
	// If additional items exist beyond the number you specify, the NextToken response
	// element is returned with a value (not null). Include the specified value as the
	// NextToken request parameter in the next call to the operation to get the next
	// set of results. Note that the service might return fewer results than the
	// maximum even when there are more results available. You should check NextToken
	// after every operation to ensure that you receive all of the results. If you do
	// not specify this parameter, the operation defaults to 10 policy templates per
	// response. You can specify a maximum of 50 policy templates per response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListPolicyTemplatesPaginatorOptions is the paginator options for ListPolicyTemplates

type Options 

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The optional application specific identifier appended to the User-Agent header.
	AppID string

	// This endpoint will be given as input to an EndpointResolverV2. It is used for
	// providing a custom base endpoint that is subject to modifications by the
	// processing EndpointResolverV2.
	BaseEndpoint *string

	// Configures the events that will be sent to the configured logger.
	ClientLogMode aws.ClientLogMode

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The configuration DefaultsMode that the SDK should use when constructing the
	// clients initial default settings.
	DefaultsMode aws.DefaultsMode

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions EndpointResolverOptions

	// The service endpoint resolver.
	//
	// Deprecated: Deprecated: EndpointResolver and WithEndpointResolver. Providing a
	// value for this field will likely prevent you from using any endpoint-related
	// service features released after the introduction of EndpointResolverV2 and
	// BaseEndpoint. To migrate an EndpointResolver implementation that uses a custom
	// endpoint, set the client option BaseEndpoint instead.
	EndpointResolver EndpointResolver

	// Resolves the endpoint used for a particular service operation. This should be
	// used over the deprecated EndpointResolver.
	EndpointResolverV2 EndpointResolverV2

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// Provides idempotency tokens values that will be automatically populated into
	// idempotent API operations.
	IdempotencyTokenProvider IdempotencyTokenProvider

	// The logger writer interface to write logging messages to.
	Logger logging.Logger

	// The region to send requests to. (Required)
	Region string

	// RetryMaxAttempts specifies the maximum number attempts an API client will call
	// an operation that fails with a retryable error. A value of 0 is ignored, and
	// will not be used to configure the API client created default retryer, or modify
	// per operation call's retry max attempts. If specified in an operation call's
	// functional options with a value that is different than the constructed client's
	// Options, the Client's Retryer will be wrapped to use the operation's specific
	// RetryMaxAttempts value.
	RetryMaxAttempts int

	// RetryMode specifies the retry mode the API client will be created with, if
	// Retryer option is not also specified. When creating a new API Clients this
	// member will only be used if the Retryer Options member is nil. This value will
	// be ignored if Retryer is not nil. Currently does not support per operation call
	// overrides, may in the future.
	RetryMode aws.RetryMode

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer. The kind of
	// default retry created by the API client can be changed with the RetryMode
	// option.
	Retryer aws.Retryer

	// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
	// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
	// should not populate this structure programmatically, or rely on the values here
	// within your applications.
	RuntimeEnvironment aws.RuntimeEnvironment

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient

	// The auth scheme resolver which determines how to authenticate for each
	// operation.
	AuthSchemeResolver AuthSchemeResolver

	// The list of auth schemes supported by the client.
	AuthSchemes []smithyhttp.AuthScheme
	// contains filtered or unexported fields
}

func (Options) Copy 

func (o Options) Copy() Options

Copy creates a clone where the APIOptions list is deep copied.

func (Options) GetIdentityResolver added in v1.5.2 

func (o Options) GetIdentityResolver(schemeID string) smithyauth.IdentityResolver

type PutSchemaInput 

type PutSchemaInput struct {

	// Specifies the definition of the schema to be stored. The schema definition must
	// be written in Cedar schema JSON.
	//
	// This member is required.
	Definition types.SchemaDefinition

	// Specifies the ID of the policy store in which to place the schema.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type PutSchemaOutput 

type PutSchemaOutput struct {

	// The date and time that the schema was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the schema was last updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// Identifies the namespaces of the entities referenced by this schema.
	//
	// This member is required.
	Namespaces []string

	// The unique ID of the policy store that contains the schema.
	//
	// This member is required.
	PolicyStoreId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ResolveEndpoint 

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  EndpointResolverOptions
}

func (*ResolveEndpoint) HandleSerialize 

func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
)

func (*ResolveEndpoint) ID 

func (*ResolveEndpoint) ID() string

type UpdateIdentitySourceInput 

type UpdateIdentitySourceInput struct {

	// Specifies the ID of the identity source that you want to update.
	//
	// This member is required.
	IdentitySourceId *string

	// Specifies the ID of the policy store that contains the identity source that you
	// want to update.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the details required to communicate with the identity provider (IdP)
	// associated with this identity source. At this time, the only valid member of
	// this structure is a Amazon Cognito user pool configuration. You must specify a
	// userPoolArn , and optionally, a ClientId .
	//
	// This member is required.
	UpdateConfiguration types.UpdateConfiguration

	// Specifies the data type of principals generated for identities authenticated by
	// the identity source.
	PrincipalEntityType *string
	// contains filtered or unexported fields
}

type UpdateIdentitySourceOutput 

type UpdateIdentitySourceOutput struct {

	// The date and time that the updated identity source was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The ID of the updated identity source.
	//
	// This member is required.
	IdentitySourceId *string

	// The date and time that the identity source was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the updated identity source.
	//
	// This member is required.
	PolicyStoreId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdatePolicyInput 

type UpdatePolicyInput struct {

	// Specifies the updated policy content that you want to replace on the specified
	// policy. The content must be valid Cedar policy language text. You can change
	// only the following elements from the policy definition:
	//   - The action referenced by the policy.
	//   - Any conditional clauses, such as when or unless clauses.
	// You can't change the following elements:
	//   - Changing from static to templateLinked .
	//   - Changing the effect of the policy from permit or forbid .
	//   - The principal referenced by the policy.
	//   - The resource referenced by the policy.
	//
	// This member is required.
	Definition types.UpdatePolicyDefinition

	// Specifies the ID of the policy that you want to update. To find this value, you
	// can use ListPolicies (https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_ListPolicies.html)
	// .
	//
	// This member is required.
	PolicyId *string

	// Specifies the ID of the policy store that contains the policy that you want to
	// update.
	//
	// This member is required.
	PolicyStoreId *string
	// contains filtered or unexported fields
}

type UpdatePolicyOutput 

type UpdatePolicyOutput struct {

	// The date and time that the policy was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the policy was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy that was updated.
	//
	// This member is required.
	PolicyId *string

	// The ID of the policy store that contains the policy that was updated.
	//
	// This member is required.
	PolicyStoreId *string

	// The type of the policy that was updated.
	//
	// This member is required.
	PolicyType types.PolicyType

	// The principal specified in the policy's scope. This element isn't included in
	// the response when Principal isn't present in the policy content.
	Principal *types.EntityIdentifier

	// The resource specified in the policy's scope. This element isn't included in
	// the response when Resource isn't present in the policy content.
	Resource *types.EntityIdentifier

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdatePolicyStoreInput 

type UpdatePolicyStoreInput struct {

	// Specifies the ID of the policy store that you want to update
	//
	// This member is required.
	PolicyStoreId *string

	// A structure that defines the validation settings that want to enable for the
	// policy store.
	//
	// This member is required.
	ValidationSettings *types.ValidationSettings

	// Descriptive text that you can provide to help with identification of the
	// current policy store.
	Description *string
	// contains filtered or unexported fields
}

type UpdatePolicyStoreOutput 

type UpdatePolicyStoreOutput struct {

	// The Amazon Resource Name (ARN) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
	// of the updated policy store.
	//
	// This member is required.
	Arn *string

	// The date and time that the policy store was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the policy store was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the updated policy store.
	//
	// This member is required.
	PolicyStoreId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdatePolicyTemplateInput 

type UpdatePolicyTemplateInput struct {

	// Specifies the ID of the policy store that contains the policy template that you
	// want to update.
	//
	// This member is required.
	PolicyStoreId *string

	// Specifies the ID of the policy template that you want to update.
	//
	// This member is required.
	PolicyTemplateId *string

	// Specifies new statement content written in Cedar policy language to replace the
	// current body of the policy template. You can change only the following elements
	// of the policy body:
	//   - The action referenced by the policy template.
	//   - Any conditional clauses, such as when or unless clauses.
	// You can't change the following elements:
	//   - The effect ( permit or forbid ) of the policy template.
	//   - The principal referenced by the policy template.
	//   - The resource referenced by the policy template.
	//
	// This member is required.
	Statement *string

	// Specifies a new description to apply to the policy template.
	Description *string
	// contains filtered or unexported fields
}

type UpdatePolicyTemplateOutput 

type UpdatePolicyTemplateOutput struct {

	// The date and time that the policy template was originally created.
	//
	// This member is required.
	CreatedDate *time.Time

	// The date and time that the policy template was most recently updated.
	//
	// This member is required.
	LastUpdatedDate *time.Time

	// The ID of the policy store that contains the updated policy template.
	//
	// This member is required.
	PolicyStoreId *string

	// The ID of the updated policy template.
	//
	// This member is required.
	PolicyTemplateId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

Source Files

View all Source files

Directories

Path Synopsis
internal
endpoints

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.