@distilled.cloud/ovh 0.0.0 → 1.0.0-rc.9

package/lib/services/iam.d.ts

@@ -0,0 +1,829 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type OvhOpError, type OvhOpContext } from "../protocol.ts";
+export type { OvhOpError, OvhOpContext };
+/** List of actions to check authorizations for */
+export type CheckIamAuthorizationRequestActionsList = Array<string>;
+export declare const CheckIamAuthorizationRequestActionsList: S.Schema<CheckIamAuthorizationRequestActionsList>;
+/** Resources on which accesses should be checked */
+export type CheckIamAuthorizationRequestResourceURNsList = Array<string>;
+export declare const CheckIamAuthorizationRequestResourceURNsList: S.Schema<CheckIamAuthorizationRequestResourceURNsList>;
+export interface CheckIamAuthorizationRequest {
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+    /** List of actions to check authorizations for */
+    actions: CheckIamAuthorizationRequestActionsList;
+    /** Resources on which accesses should be checked */
+    resourceURNs: CheckIamAuthorizationRequestResourceURNsList;
+}
+export declare const CheckIamAuthorizationRequest: S.Schema<CheckIamAuthorizationRequest>;
+/** Authorized actions */
+export type IamAuthorizeBatchResponseAuthorizedActionsList = Array<string>;
+export declare const IamAuthorizeBatchResponseAuthorizedActionsList: S.Schema<IamAuthorizeBatchResponseAuthorizedActionsList>;
+/** Unauthorized actions */
+export type IamAuthorizeBatchResponseUnauthorizedActionsList = Array<string>;
+export declare const IamAuthorizeBatchResponseUnauthorizedActionsList: S.Schema<IamAuthorizeBatchResponseUnauthorizedActionsList>;
+/** Result of an authorization request */
+export interface IamAuthorizeBatchResponse {
+    /** Authorized actions */
+    authorizedActions?: IamAuthorizeBatchResponseAuthorizedActionsList;
+    /** URN of the resource */
+    resourceURN?: string;
+    /** Unauthorized actions */
+    unauthorizedActions?: IamAuthorizeBatchResponseUnauthorizedActionsList;
+}
+export declare const IamAuthorizeBatchResponse: S.Schema<IamAuthorizeBatchResponse>;
+export type CheckIamAuthorizationResponseBodyList = Array<IamAuthorizeBatchResponse>;
+export declare const CheckIamAuthorizationResponseBodyList: S.Schema<CheckIamAuthorizationResponseBodyList>;
+export type CheckIamAuthorizationResponse = CheckIamAuthorizationResponseBodyList;
+export declare const CheckIamAuthorizationResponse: S.Schema<CheckIamAuthorizationResponse>;
+/** List of actions to check authorizations for */
+export type CheckIamResourceAuthorizationRequestActionsList = Array<string>;
+export declare const CheckIamResourceAuthorizationRequestActionsList: S.Schema<CheckIamResourceAuthorizationRequestActionsList>;
+export interface CheckIamResourceAuthorizationRequest {
+    /** ResourceURN */
+    resourceURN: string;
+    /** List of actions to check authorizations for */
+    actions: CheckIamResourceAuthorizationRequestActionsList;
+}
+export declare const CheckIamResourceAuthorizationRequest: S.Schema<CheckIamResourceAuthorizationRequest>;
+/** Authorized actions */
+export type IamAuthorizeResponseAuthorizedActionsList = Array<string>;
+export declare const IamAuthorizeResponseAuthorizedActionsList: S.Schema<IamAuthorizeResponseAuthorizedActionsList>;
+/** Unauthorized actions */
+export type IamAuthorizeResponseUnauthorizedActionsList = Array<string>;
+export declare const IamAuthorizeResponseUnauthorizedActionsList: S.Schema<IamAuthorizeResponseUnauthorizedActionsList>;
+/** Result of an authorization request */
+export interface IamAuthorizeResponse {
+    /** Authorized actions */
+    authorizedActions?: IamAuthorizeResponseAuthorizedActionsList;
+    /** Unauthorized actions */
+    unauthorizedActions?: IamAuthorizeResponseUnauthorizedActionsList;
+}
+export declare const IamAuthorizeResponse: S.Schema<IamAuthorizeResponse>;
+export interface CreateIamLogSubscriptionRequest {
+    /** Log kind name to subscribe to */
+    kind: string;
+    /** Customer log stream ID */
+    streamId: string;
+}
+export declare const CreateIamLogSubscriptionRequest: S.Schema<CreateIamLogSubscriptionRequest>;
+/** Asynchronous operation after subscribing or unsubscribing to a resource logs */
+export interface DbaasLogsLogSubscriptionResponse {
+    /** Identifier of the operation */
+    operationId?: string;
+    /** Operation owner's service name */
+    serviceName?: string;
+}
+export declare const DbaasLogsLogSubscriptionResponse: S.Schema<DbaasLogsLogSubscriptionResponse>;
+export interface CreateIamLogUrlRequest {
+    /** Log kind name */
+    kind: string;
+}
+export declare const CreateIamLogUrlRequest: S.Schema<CreateIamLogUrlRequest>;
+/** Temporary url information */
+export interface DbaasLogsTemporaryLogsLink {
+    /** Temporary url expiration date */
+    expirationDate?: string;
+    /** Temporary url */
+    url?: string;
+}
+export declare const DbaasLogsTemporaryLogsLink: S.Schema<DbaasLogsTemporaryLogsLink>;
+/** Action that can be allowed or denied on a resource */
+export interface IamPolicyAction {
+    /** Name of the action */
+    action: string;
+}
+export declare const IamPolicyAction: S.Schema<IamPolicyAction>;
+/** List of allowed actions */
+export type IamPolicyPermissionsAllowList = Array<IamPolicyAction>;
+export declare const IamPolicyPermissionsAllowList: S.Schema<IamPolicyPermissionsAllowList>;
+/** Actions to deny the access to */
+export type IamPolicyPermissionsDenyList = Array<IamPolicyAction>;
+export declare const IamPolicyPermissionsDenyList: S.Schema<IamPolicyPermissionsDenyList>;
+/** Actions to filter from the allowed list */
+export type IamPolicyPermissionsExceptList = Array<IamPolicyAction>;
+export declare const IamPolicyPermissionsExceptList: S.Schema<IamPolicyPermissionsExceptList>;
+/** Permissions included in a policy */
+export interface IamPolicyPermissions {
+    /** List of allowed actions */
+    allow?: IamPolicyPermissionsAllowList | null;
+    /** Actions to deny the access to */
+    deny?: IamPolicyPermissionsDenyList | null;
+    /** Actions to filter from the allowed list */
+    except?: IamPolicyPermissionsExceptList | null;
+}
+export declare const IamPolicyPermissions: S.Schema<IamPolicyPermissions>;
+export interface CreateIamPermissionsGroupRequest {
+    /** Description of the permissions group */
+    description: string;
+    /** Name of the permissions group */
+    name: string;
+    /** Permissions granted when using this permissions group */
+    permissions: IamPolicyPermissions;
+}
+export declare const CreateIamPermissionsGroupRequest: S.Schema<CreateIamPermissionsGroupRequest>;
+/** Permissions group defines a re-usable set of permissions */
+export interface IamPermissionsGroup {
+    /** Creation time */
+    createdAt?: string;
+    /** Description of the permissions group */
+    description: string;
+    /** Unique identifier of the permissions group */
+    id?: string;
+    /** Name of the permissions group */
+    name: string;
+    /** Owner of the permissions group */
+    owner?: string;
+    /** Permissions granted when using this permissions group */
+    permissions: IamPolicyPermissions;
+    /** Last update time */
+    updatedAt?: string | null;
+    /** Unique resource name used in policies to include this permissions group */
+    urn?: string;
+}
+export declare const IamPermissionsGroup: S.Schema<IamPermissionsGroup>;
+/** conditions */
+export type IamPolicyConditionConditionsList = Array<IamPolicyCondition>;
+export declare const IamPolicyConditionConditionsList: S.Schema<IamPolicyConditionConditionsList>;
+/** Operator that can be used in order to restrict policy */
+export type IamPolicyConditionOperatorEnum = "AND" | "MATCH" | "NOT" | "OR";
+export declare const IamPolicyConditionOperatorEnum: any;
+/** Conditions to apply */
+export type IamPolicyConditionValuesMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamPolicyConditionValuesMap: S.Schema<IamPolicyConditionValuesMap>;
+/** Condition included in a policy */
+export interface IamPolicyCondition {
+    /** conditions */
+    conditions?: IamPolicyConditionConditionsList | null;
+    /** Operator used with conditions */
+    operator?: IamPolicyConditionOperatorEnum | (string & {});
+    /** Conditions to apply */
+    values?: IamPolicyConditionValuesMap | null;
+}
+export declare const IamPolicyCondition: S.Schema<IamPolicyCondition>;
+/** Recipients of the delegated resources */
+export type CreateIamPolicyRequestIdentitiesList = Array<string>;
+export declare const CreateIamPolicyRequestIdentitiesList: S.Schema<CreateIamPolicyRequestIdentitiesList>;
+/** Permissions group linked to a policy */
+export interface IamPolicyPermissionsGroupInput {
+    /** URN of the permissions group */
+    urn?: string;
+}
+export declare const IamPolicyPermissionsGroupInput: S.Schema<IamPolicyPermissionsGroupInput>;
+/** Permissions groups accorded to the recipients on the given resources */
+export type CreateIamPolicyRequestPermissionsGroupsList = Array<IamPolicyPermissionsGroupInput>;
+export declare const CreateIamPolicyRequestPermissionsGroupsList: S.Schema<CreateIamPolicyRequestPermissionsGroupsList>;
+/** Resource in a policy */
+export interface IamPolicyResourceInput {
+    /** URN of the resource */
+    urn: string;
+}
+export declare const IamPolicyResourceInput: S.Schema<IamPolicyResourceInput>;
+/** Resources to delegate */
+export type CreateIamPolicyRequestResourcesList = Array<IamPolicyResourceInput>;
+export declare const CreateIamPolicyRequestResourcesList: S.Schema<CreateIamPolicyRequestResourcesList>;
+export interface CreateIamPolicyRequest {
+    /** Conditions restrict permissions following resources, date or customer's information */
+    conditions?: IamPolicyCondition | null;
+    /** Description of the policy */
+    description?: string;
+    /** Expiration date of the policy, after this date it will no longer be applied */
+    expiredAt?: string | null;
+    /** Recipients of the delegated resources */
+    identities: CreateIamPolicyRequestIdentitiesList;
+    /** Name of the policy */
+    name: string;
+    /** Permissions accorded to the recipients on the given resources */
+    permissions: IamPolicyPermissions;
+    /** Permissions groups accorded to the recipients on the given resources */
+    permissionsGroups?: CreateIamPolicyRequestPermissionsGroupsList | null;
+    /** Resources to delegate */
+    resources: CreateIamPolicyRequestResourcesList;
+}
+export declare const CreateIamPolicyRequest: S.Schema<CreateIamPolicyRequest>;
+/** Recipients of the delegated resources */
+export type IamPolicyResponseIdentitiesList = Array<string>;
+export declare const IamPolicyResponseIdentitiesList: S.Schema<IamPolicyResponseIdentitiesList>;
+/** Permissions group linked to a policy */
+export interface IamPolicyPermissionsGroup {
+    /** Name of the permissions group */
+    name?: string | null;
+    /** Owner of the permissions group */
+    owner?: string | null;
+    /** Permissions embedded in the permissions group */
+    permissions?: IamPolicyPermissions | null;
+    /** URN of the permissions group */
+    urn?: string;
+}
+export declare const IamPolicyPermissionsGroup: S.Schema<IamPolicyPermissionsGroup>;
+/** Permissions groups accorded to the recipients on the given resources */
+export type IamPolicyResponsePermissionsGroupsList = Array<IamPolicyPermissionsGroup>;
+export declare const IamPolicyResponsePermissionsGroupsList: S.Schema<IamPolicyResponsePermissionsGroupsList>;
+/** Group defines a set of resources */
+export interface IamPolicyGroup {
+    /** Unique identifier of the group */
+    id?: string;
+    /** Name of the group */
+    name?: string;
+    /** Whether you can add or remove resources */
+    readOnly?: boolean;
+}
+export declare const IamPolicyGroup: S.Schema<IamPolicyGroup>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamPolicySingleResourceTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamPolicySingleResourceTagsMap: S.Schema<IamPolicySingleResourceTagsMap>;
+/** Single resource in a policy */
+export interface IamPolicySingleResource {
+    /** Display name of the resource */
+    displayName?: string;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Name of the resource */
+    name?: string;
+    /** Owner of the resource */
+    owner?: string;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamPolicySingleResourceTagsMap | null;
+    /** Resource type. All types can be retrieved at /reference/resource/type */
+    type?: string;
+}
+export declare const IamPolicySingleResource: S.Schema<IamPolicySingleResource>;
+/** Resource in a policy */
+export interface IamPolicyResource {
+    /** Group object, if resource is a group */
+    group?: IamPolicyGroup | null;
+    /** Resource object, if resource is a single resource */
+    resource?: IamPolicySingleResource | null;
+    /** URN of the resource */
+    urn: string;
+}
+export declare const IamPolicyResource: S.Schema<IamPolicyResource>;
+/** Resources to delegate */
+export type IamPolicyResponseResourcesList = Array<IamPolicyResource>;
+export declare const IamPolicyResponseResourcesList: S.Schema<IamPolicyResponseResourcesList>;
+/** Policy definition */
+export interface IamPolicyResponse {
+    /** Conditions restrict permissions following resources, date or customer's information */
+    conditions?: IamPolicyCondition | null;
+    /** Creation time */
+    createdAt?: string;
+    /** Description of the policy */
+    description?: string | null;
+    /** Expiration date of the policy, after this date it will no longer be applied */
+    expiredAt?: string | null;
+    /** Unique identifier of the policy */
+    id?: string;
+    /** Recipients of the delegated resources */
+    identities?: IamPolicyResponseIdentitiesList;
+    /** Name of the policy */
+    name?: string;
+    /** Owner of the policy */
+    owner?: string;
+    /** Permissions accorded to the recipients on the given resources */
+    permissions?: IamPolicyPermissions;
+    /** Permissions groups accorded to the recipients on the given resources */
+    permissionsGroups?: IamPolicyResponsePermissionsGroupsList;
+    /** Whether you can update policy */
+    readOnly?: boolean;
+    /** Resources to delegate */
+    resources?: IamPolicyResponseResourcesList;
+    /** Last update time */
+    updatedAt?: string | null;
+}
+export declare const IamPolicyResponse: S.Schema<IamPolicyResponse>;
+/** Resource is an entity standing for a product. It is used for right delegation */
+export interface IamGroupResourceInput {
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Unique resource name used in policies */
+    urn?: string | null;
+}
+export declare const IamGroupResourceInput: S.Schema<IamGroupResourceInput>;
+/** Resources to add in the created group */
+export type CreateIamResourceGroupRequestResourcesList = Array<IamGroupResourceInput>;
+export declare const CreateIamResourceGroupRequestResourcesList: S.Schema<CreateIamResourceGroupRequestResourcesList>;
+export interface CreateIamResourceGroupRequest {
+    /** Name of the group */
+    name: string;
+    /** Resources to add in the created group */
+    resources?: CreateIamResourceGroupRequestResourcesList;
+}
+export declare const CreateIamResourceGroupRequest: S.Schema<CreateIamResourceGroupRequest>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamGroupResourceTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamGroupResourceTagsMap: S.Schema<IamGroupResourceTagsMap>;
+/** Resource is an entity standing for a product. It is used for right delegation */
+export interface IamGroupResource {
+    /** Resource display name */
+    displayName?: string | null;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Resource name */
+    name?: string | null;
+    /** Resource owner */
+    owner?: string | null;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamGroupResourceTagsMap | null;
+    /** Resource type. All types can be retrieved at /reference/resource/type */
+    type?: string | null;
+    /** Unique resource name used in policies */
+    urn?: string | null;
+}
+export declare const IamGroupResource: S.Schema<IamGroupResource>;
+/** Resources included in the group */
+export type IamGroupResponseResourcesList = Array<IamGroupResource>;
+export declare const IamGroupResponseResourcesList: S.Schema<IamGroupResponseResourcesList>;
+/** Group defines a set of resources */
+export interface IamGroupResponse {
+    /** Creation time */
+    createdAt?: string;
+    /** Unique identifier of the group */
+    id?: string;
+    /** Name of the group */
+    name?: string;
+    /** Owner of the group */
+    owner?: string;
+    /** Whether you can add or remove resources */
+    readOnly?: boolean;
+    /** Resources included in the group */
+    resources?: IamGroupResponseResourcesList;
+    /** Last update time */
+    updatedAt?: string | null;
+    /** Unique resource name used in policies */
+    urn?: string;
+}
+export declare const IamGroupResponse: S.Schema<IamGroupResponse>;
+export interface CreateIamResourceTagRequest {
+    /** ResourceURN */
+    resourceURN: string;
+    /** Resource tag key. It must comply with '^[a-zA-Z0-9_.:/=+@-]{1,128}\z' */
+    key: string;
+    /** Resource tag value. It must comply with '^[a-zA-Z0-9_.:/=+@-]{0,256}\z' */
+    value: string;
+}
+export declare const CreateIamResourceTagRequest: S.Schema<CreateIamResourceTagRequest>;
+export interface CreateIamResourceTagResponse {
+}
+export declare const CreateIamResourceTagResponse: S.Schema<CreateIamResourceTagResponse>;
+export interface DeleteIamLogSubscriptionRequest {
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const DeleteIamLogSubscriptionRequest: S.Schema<DeleteIamLogSubscriptionRequest>;
+export interface DeleteIamPermissionsGroupRequest {
+    /** Permissions groupurn */
+    permissionsGroupURN: string;
+}
+export declare const DeleteIamPermissionsGroupRequest: S.Schema<DeleteIamPermissionsGroupRequest>;
+export interface DeleteIamPermissionsGroupResponse {
+}
+export declare const DeleteIamPermissionsGroupResponse: S.Schema<DeleteIamPermissionsGroupResponse>;
+export interface DeleteIamPolicyRequest {
+    /** Policy ID */
+    policyId: string;
+}
+export declare const DeleteIamPolicyRequest: S.Schema<DeleteIamPolicyRequest>;
+export interface DeleteIamPolicyResponse {
+}
+export declare const DeleteIamPolicyResponse: S.Schema<DeleteIamPolicyResponse>;
+export interface DeleteIamResourceGroupRequest {
+    /** Group ID */
+    groupId: string;
+}
+export declare const DeleteIamResourceGroupRequest: S.Schema<DeleteIamResourceGroupRequest>;
+export interface DeleteIamResourceGroupResponse {
+}
+export declare const DeleteIamResourceGroupResponse: S.Schema<DeleteIamResourceGroupResponse>;
+export interface DeleteIamResourceTagRequest {
+    /** ResourceURN */
+    resourceURN: string;
+    /** Key */
+    key: string;
+}
+export declare const DeleteIamResourceTagRequest: S.Schema<DeleteIamResourceTagRequest>;
+export interface DeleteIamResourceTagResponse {
+}
+export declare const DeleteIamResourceTagResponse: S.Schema<DeleteIamResourceTagResponse>;
+export interface GetIamLogKindRequest {
+    /** Name */
+    name: string;
+}
+export declare const GetIamLogKindRequest: S.Schema<GetIamLogKindRequest>;
+/** List of additional log fields managed in this log kind */
+export type DbaasLogsLogKindAdditionalReturnedFieldsList = Array<string>;
+export declare const DbaasLogsLogKindAdditionalReturnedFieldsList: S.Schema<DbaasLogsLogKindAdditionalReturnedFieldsList>;
+/** Log kind */
+export interface DbaasLogsLogKind {
+    /** List of additional log fields managed in this log kind */
+    additionalReturnedFields?: DbaasLogsLogKindAdditionalReturnedFieldsList;
+    /** Creation date of the log kind */
+    createdAt?: string;
+    /** Log kind display name */
+    displayName?: string;
+    /** Log kind ID */
+    kindId?: string;
+    /** Log kind name */
+    name?: string;
+    /** Last update date of the log kind */
+    updatedAt?: string;
+}
+export declare const DbaasLogsLogKind: S.Schema<DbaasLogsLogKind>;
+export interface GetIamLogSubscriptionRequest {
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const GetIamLogSubscriptionRequest: S.Schema<GetIamLogSubscriptionRequest>;
+/** Log subscription resource */
+export interface DbaasLogsLogSubscriptionResource {
+    /** Name of subscribed resource */
+    name?: string;
+    /** Type of subscribed resource */
+    type?: string;
+}
+export declare const DbaasLogsLogSubscriptionResource: S.Schema<DbaasLogsLogSubscriptionResource>;
+/** Log subscription */
+export interface DbaasLogsLogSubscription {
+    /** Creation date of the subscription */
+    createdAt?: string;
+    /** Log kind name of this subscription */
+    kind?: string;
+    /** Subscribed resource, where the logs come from */
+    resource?: DbaasLogsLogSubscriptionResource;
+    /** Name of the destination log service */
+    serviceName?: string;
+    /** Id of the destination log stream */
+    streamId?: string;
+    /** Subscription ID */
+    subscriptionId?: string;
+    /** Last update date of the subscription */
+    updatedAt?: string;
+}
+export declare const DbaasLogsLogSubscription: S.Schema<DbaasLogsLogSubscription>;
+export interface GetIamPermissionsGroupRequest {
+    /** Permissions groupurn */
+    permissionsGroupURN: string;
+}
+export declare const GetIamPermissionsGroupRequest: S.Schema<GetIamPermissionsGroupRequest>;
+export interface GetIamPolicyRequest {
+    /** Policy ID */
+    policyId: string;
+    /** Add extra information about resources in output */
+    details?: boolean;
+}
+export declare const GetIamPolicyRequest: S.Schema<GetIamPolicyRequest>;
+export interface GetIamResourceRequest {
+    /** ResourceURN */
+    resourceURN: string;
+}
+export declare const GetIamResourceRequest: S.Schema<GetIamResourceRequest>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceResourceTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamResourceResourceTagsMap: S.Schema<IamResourceResourceTagsMap>;
+/** Resource is an entity standing for a product. It is used for right delegation */
+export interface IamResourceResource {
+    /** Resource display name */
+    displayName?: string;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Resource name */
+    name?: string;
+    /** Resource owner */
+    owner?: string;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamResourceResourceTagsMap | null;
+    /** Resource type. All types can be retrieved at /reference/resource/type */
+    type?: string;
+    /** Unique resource name used in policies */
+    urn?: string;
+}
+export declare const IamResourceResource: S.Schema<IamResourceResource>;
+export interface GetIamResourceGroupRequest {
+    /** Group ID */
+    groupId: string;
+    /** Add extra information about resources in output */
+    details?: boolean;
+}
+export declare const GetIamResourceGroupRequest: S.Schema<GetIamResourceGroupRequest>;
+export interface ListIamLogKindRequest {
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamLogKindRequest: S.Schema<ListIamLogKindRequest>;
+export type ListIamLogKindResponseBodyList = Array<string>;
+export declare const ListIamLogKindResponseBodyList: S.Schema<ListIamLogKindResponseBodyList>;
+export type ListIamLogKindResponse = ListIamLogKindResponseBodyList;
+export declare const ListIamLogKindResponse: S.Schema<ListIamLogKindResponse>;
+export interface ListIamLogSubscriptionRequest {
+    /** Filter on a specific kind (e.g., default) */
+    kind?: string;
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamLogSubscriptionRequest: S.Schema<ListIamLogSubscriptionRequest>;
+export type ListIamLogSubscriptionResponseBodyList = Array<string>;
+export declare const ListIamLogSubscriptionResponseBodyList: S.Schema<ListIamLogSubscriptionResponseBodyList>;
+export type ListIamLogSubscriptionResponse = ListIamLogSubscriptionResponseBodyList;
+export declare const ListIamLogSubscriptionResponse: S.Schema<ListIamLogSubscriptionResponse>;
+export interface ListIamPermissionsGroupRequest {
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamPermissionsGroupRequest: S.Schema<ListIamPermissionsGroupRequest>;
+export type ListIamPermissionsGroupResponseBodyList = Array<IamPermissionsGroup>;
+export declare const ListIamPermissionsGroupResponseBodyList: S.Schema<ListIamPermissionsGroupResponseBodyList>;
+export type ListIamPermissionsGroupResponse = ListIamPermissionsGroupResponseBodyList;
+export declare const ListIamPermissionsGroupResponse: S.Schema<ListIamPermissionsGroupResponse>;
+export type ListIamPolicyRequestActionList = Array<string>;
+export declare const ListIamPolicyRequestActionList: S.Schema<ListIamPolicyRequestActionList>;
+export type ListIamPolicyRequestIdentityList = Array<string>;
+export declare const ListIamPolicyRequestIdentityList: S.Schema<ListIamPolicyRequestIdentityList>;
+export type ListIamPolicyRequestResourceURNList = Array<string>;
+export declare const ListIamPolicyRequestResourceURNList: S.Schema<ListIamPolicyRequestResourceURNList>;
+export interface ListIamPolicyRequest {
+    /** Filter on policies embedding the given IAM action */
+    action?: ListIamPolicyRequestActionList;
+    /** Add extra information about resources in output */
+    details?: boolean;
+    /** Filter on policies embedding the given identity */
+    identity?: ListIamPolicyRequestIdentityList;
+    /** Filter on the readOnly attribute */
+    readOnly?: boolean;
+    /** Filter on policies embedding the given resource URN */
+    resourceURN?: ListIamPolicyRequestResourceURNList;
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamPolicyRequest: S.Schema<ListIamPolicyRequest>;
+export type ListIamPolicyResponseBodyList = Array<IamPolicyResponse>;
+export declare const ListIamPolicyResponseBodyList: S.Schema<ListIamPolicyResponseBodyList>;
+export type ListIamPolicyResponse = ListIamPolicyResponseBodyList;
+export declare const ListIamPolicyResponse: S.Schema<ListIamPolicyResponse>;
+export type ListIamReferenceActionRequestResourceTypeList = Array<string>;
+export declare const ListIamReferenceActionRequestResourceTypeList: S.Schema<ListIamReferenceActionRequestResourceTypeList>;
+export interface ListIamReferenceActionRequest {
+    /** Filter actions for specific resource types */
+    resourceType?: ListIamReferenceActionRequestResourceTypeList;
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamReferenceActionRequest: S.Schema<ListIamReferenceActionRequest>;
+/** List of categories the action belongs to */
+export type IamReferenceActionCategoriesList = Array<string>;
+export declare const IamReferenceActionCategoriesList: S.Schema<IamReferenceActionCategoriesList>;
+/** Action that can be allowed or denied on a resource */
+export interface IamReferenceAction {
+    /** Name of the action */
+    action?: string;
+    /** List of categories the action belongs to */
+    categories?: IamReferenceActionCategoriesList;
+    /** Description of the action */
+    description?: string;
+    /** Whether you can use the action with additional parameters */
+    hasQueryParameters?: boolean;
+    /** Resource type related to the action */
+    resourceType?: string;
+}
+export declare const IamReferenceAction: S.Schema<IamReferenceAction>;
+export type ListIamReferenceActionResponseBodyList = Array<IamReferenceAction>;
+export declare const ListIamReferenceActionResponseBodyList: S.Schema<ListIamReferenceActionResponseBodyList>;
+export type ListIamReferenceActionResponse = ListIamReferenceActionResponseBodyList;
+export declare const ListIamReferenceActionResponse: S.Schema<ListIamReferenceActionResponse>;
+export interface ListIamReferenceResourceTypeRequest {
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamReferenceResourceTypeRequest: S.Schema<ListIamReferenceResourceTypeRequest>;
+export type ListIamReferenceResourceTypeResponseBodyList = Array<string>;
+export declare const ListIamReferenceResourceTypeResponseBodyList: S.Schema<ListIamReferenceResourceTypeResponseBodyList>;
+export type ListIamReferenceResourceTypeResponse = ListIamReferenceResourceTypeResponseBodyList;
+export declare const ListIamReferenceResourceTypeResponse: S.Schema<ListIamReferenceResourceTypeResponse>;
+export type ListIamResourceRequestResourceNameList = Array<string>;
+export declare const ListIamResourceRequestResourceNameList: S.Schema<ListIamResourceRequestResourceNameList>;
+export type ListIamResourceRequestResourceTypeList = Array<string>;
+export declare const ListIamResourceRequestResourceTypeList: S.Schema<ListIamResourceRequestResourceTypeList>;
+export type ListIamResourceRequestResourceURNList = Array<string>;
+export declare const ListIamResourceRequestResourceURNList: S.Schema<ListIamResourceRequestResourceURNList>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListIamResourceRequestTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListIamResourceRequestTagsValueList: S.Schema<ListIamResourceRequestTagsValueList>;
+export type ListIamResourceRequestTagsMap = {
+    [key: string]: ListIamResourceRequestTagsValueList | undefined;
+};
+export declare const ListIamResourceRequestTagsMap: S.Schema<ListIamResourceRequestTagsMap>;
+export interface ListIamResourceRequest {
+    /** Filter resources for specific resource names */
+    resourceName?: ListIamResourceRequestResourceNameList;
+    /** Filter resources for specific resource types */
+    resourceType?: ListIamResourceRequestResourceTypeList;
+    /** Filter resources for specific resource URN patterns */
+    resourceURN?: ListIamResourceRequestResourceURNList;
+    /** Filter resources using tag filters */
+    tags?: ListIamResourceRequestTagsMap;
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamResourceRequest: S.Schema<ListIamResourceRequest>;
+export type ListIamResourceResponseBodyList = Array<IamResourceResource>;
+export declare const ListIamResourceResponseBodyList: S.Schema<ListIamResourceResponseBodyList>;
+export type ListIamResourceResponse = ListIamResourceResponseBodyList;
+export declare const ListIamResourceResponse: S.Schema<ListIamResourceResponse>;
+export interface ListIamResourceGroupRequest {
+    /** Add extra information about resources in output */
+    details?: boolean;
+    /** Pagination cursor */
+    xPaginationCursor?: string;
+    /** Pagination size */
+    xPaginationSize?: number;
+}
+export declare const ListIamResourceGroupRequest: S.Schema<ListIamResourceGroupRequest>;
+export type ListIamResourceGroupResponseBodyList = Array<IamGroupResponse>;
+export declare const ListIamResourceGroupResponseBodyList: S.Schema<ListIamResourceGroupResponseBodyList>;
+export type ListIamResourceGroupResponse = ListIamResourceGroupResponseBodyList;
+export declare const ListIamResourceGroupResponse: S.Schema<ListIamResourceGroupResponse>;
+export interface PutIamPermissionsGroupRequest {
+    /** Permissions groupurn */
+    permissionsGroupURN: string;
+    /** Description of the permissions group */
+    description: string;
+    /** Name of the permissions group */
+    name: string;
+    /** Permissions granted when using this permissions group */
+    permissions: IamPolicyPermissions;
+}
+export declare const PutIamPermissionsGroupRequest: S.Schema<PutIamPermissionsGroupRequest>;
+/** Recipients of the delegated resources */
+export type PutIamPolicyRequestIdentitiesList = Array<string>;
+export declare const PutIamPolicyRequestIdentitiesList: S.Schema<PutIamPolicyRequestIdentitiesList>;
+/** Permissions groups accorded to the recipients on the given resources */
+export type PutIamPolicyRequestPermissionsGroupsList = Array<IamPolicyPermissionsGroupInput>;
+export declare const PutIamPolicyRequestPermissionsGroupsList: S.Schema<PutIamPolicyRequestPermissionsGroupsList>;
+/** Resources to delegate */
+export type PutIamPolicyRequestResourcesList = Array<IamPolicyResourceInput>;
+export declare const PutIamPolicyRequestResourcesList: S.Schema<PutIamPolicyRequestResourcesList>;
+export interface PutIamPolicyRequest {
+    /** Policy ID */
+    policyId: string;
+    /** Conditions restrict permissions following resources, date or customer's information */
+    conditions?: IamPolicyCondition | null;
+    /** Description of the policy */
+    description?: string;
+    /** Expiration date of the policy, after this date it will no longer be applied */
+    expiredAt?: string | null;
+    /** Recipients of the delegated resources */
+    identities: PutIamPolicyRequestIdentitiesList;
+    /** Name of the policy */
+    name: string;
+    /** Permissions accorded to the recipients on the given resources */
+    permissions: IamPolicyPermissions;
+    /** Permissions groups accorded to the recipients on the given resources */
+    permissionsGroups?: PutIamPolicyRequestPermissionsGroupsList | null;
+    /** Resources to delegate */
+    resources: PutIamPolicyRequestResourcesList;
+}
+export declare const PutIamPolicyRequest: S.Schema<PutIamPolicyRequest>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type PutIamResourceRequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const PutIamResourceRequestTagsMap: S.Schema<PutIamResourceRequestTagsMap>;
+export interface PutIamResourceRequest {
+    /** ResourceURN */
+    resourceURN: string;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: PutIamResourceRequestTagsMap | null;
+}
+export declare const PutIamResourceRequest: S.Schema<PutIamResourceRequest>;
+/** New list of resources of the group */
+export type PutIamResourceGroupRequestResourcesList = Array<IamGroupResourceInput>;
+export declare const PutIamResourceGroupRequestResourcesList: S.Schema<PutIamResourceGroupRequestResourcesList>;
+export interface PutIamResourceGroupRequest {
+    /** Group ID */
+    groupId: string;
+    /** New name of the group */
+    name: string;
+    /** New list of resources of the group */
+    resources: PutIamResourceGroupRequestResourcesList;
+}
+export declare const PutIamResourceGroupRequest: S.Schema<PutIamResourceGroupRequest>;
+export type CheckIamAuthorizationError = OvhOpError;
+/** Validate your authorizations on given resources */
+export declare const checkIamAuthorization: API.OperationMethod<CheckIamAuthorizationRequest, CheckIamAuthorizationResponse, CheckIamAuthorizationError, OvhOpContext>;
+export type CheckIamResourceAuthorizationError = OvhOpError;
+/** Validate authorizations on a given resource */
+export declare const checkIamResourceAuthorization: API.OperationMethod<CheckIamResourceAuthorizationRequest, IamAuthorizeResponse, CheckIamResourceAuthorizationError, OvhOpContext>;
+export type CreateIamLogSubscriptionError = OvhOpError;
+/** Create a subscription from logs to a pre-existing LDP stream */
+export declare const createIamLogSubscription: API.OperationMethod<CreateIamLogSubscriptionRequest, DbaasLogsLogSubscriptionResponse, CreateIamLogSubscriptionError, OvhOpContext>;
+export type CreateIamLogUrlError = OvhOpError;
+/** Generate a temporary URL to retrieve logs */
+export declare const createIamLogUrl: API.OperationMethod<CreateIamLogUrlRequest, DbaasLogsTemporaryLogsLink, CreateIamLogUrlError, OvhOpContext>;
+export type CreateIamPermissionsGroupError = OvhOpError;
+/** Create a permissions group */
+export declare const createIamPermissionsGroup: API.OperationMethod<CreateIamPermissionsGroupRequest, IamPermissionsGroup, CreateIamPermissionsGroupError, OvhOpContext>;
+export type CreateIamPolicyError = OvhOpError;
+/** Create a new policy */
+export declare const createIamPolicy: API.OperationMethod<CreateIamPolicyRequest, IamPolicyResponse, CreateIamPolicyError, OvhOpContext>;
+export type CreateIamResourceGroupError = OvhOpError;
+/** Create a new resource group */
+export declare const createIamResourceGroup: API.OperationMethod<CreateIamResourceGroupRequest, IamGroupResponse, CreateIamResourceGroupError, OvhOpContext>;
+export type CreateIamResourceTagError = OvhOpError;
+/** Add a tag to a resource Add a tag to a resource\ This action requires to be granted on action '$resourceType:apiovh:iam/resource/tag/add' (with $resourceType the type of the updated resource) */
+export declare const createIamResourceTag: API.OperationMethod<CreateIamResourceTagRequest, CreateIamResourceTagResponse, CreateIamResourceTagError, OvhOpContext>;
+export type DeleteIamLogSubscriptionError = OvhOpError;
+/** Delete a subscription */
+export declare const deleteIamLogSubscription: API.OperationMethod<DeleteIamLogSubscriptionRequest, DbaasLogsLogSubscriptionResponse, DeleteIamLogSubscriptionError, OvhOpContext>;
+export type DeleteIamPermissionsGroupError = OvhOpError;
+/** Delete the given permissions group */
+export declare const deleteIamPermissionsGroup: API.OperationMethod<DeleteIamPermissionsGroupRequest, DeleteIamPermissionsGroupResponse, DeleteIamPermissionsGroupError, OvhOpContext>;
+export type DeleteIamPolicyError = OvhOpError;
+/** Delete the given policy */
+export declare const deleteIamPolicy: API.OperationMethod<DeleteIamPolicyRequest, DeleteIamPolicyResponse, DeleteIamPolicyError, OvhOpContext>;
+export type DeleteIamResourceGroupError = OvhOpError;
+/** Delete the given resource group */
+export declare const deleteIamResourceGroup: API.OperationMethod<DeleteIamResourceGroupRequest, DeleteIamResourceGroupResponse, DeleteIamResourceGroupError, OvhOpContext>;
+export type DeleteIamResourceTagError = OvhOpError;
+/** Remove a tag from a resource Remove a tag from a resource\ This action requires to be granted on action '$resourceType:apiovh:iam/resource/tag/remove' (with $resourceType the type of the updated resource) */
+export declare const deleteIamResourceTag: API.OperationMethod<DeleteIamResourceTagRequest, DeleteIamResourceTagResponse, DeleteIamResourceTagError, OvhOpContext>;
+export type GetIamLogKindError = OvhOpError;
+/** Get a log kind */
+export declare const getIamLogKind: API.OperationMethod<GetIamLogKindRequest, DbaasLogsLogKind, GetIamLogKindError, OvhOpContext>;
+export type GetIamLogSubscriptionError = OvhOpError;
+/** Get subscription details */
+export declare const getIamLogSubscription: API.OperationMethod<GetIamLogSubscriptionRequest, DbaasLogsLogSubscription, GetIamLogSubscriptionError, OvhOpContext>;
+export type GetIamPermissionsGroupError = OvhOpError;
+/** Retrieve the given permissions group */
+export declare const getIamPermissionsGroup: API.OperationMethod<GetIamPermissionsGroupRequest, IamPermissionsGroup, GetIamPermissionsGroupError, OvhOpContext>;
+export type GetIamPolicyError = OvhOpError;
+/** Retrieve the given policy */
+export declare const getIamPolicy: API.OperationMethod<GetIamPolicyRequest, IamPolicyResponse, GetIamPolicyError, OvhOpContext>;
+export type GetIamResourceError = OvhOpError;
+/** Retrieve a resource */
+export declare const getIamResource: API.OperationMethod<GetIamResourceRequest, IamResourceResource, GetIamResourceError, OvhOpContext>;
+export type GetIamResourceGroupError = OvhOpError;
+/** Retrieve the given resource group */
+export declare const getIamResourceGroup: API.OperationMethod<GetIamResourceGroupRequest, IamGroupResponse, GetIamResourceGroupError, OvhOpContext>;
+export type ListIamLogKindError = OvhOpError;
+/** List available log kinds */
+export declare const listIamLogKind: API.OperationMethod<ListIamLogKindRequest, ListIamLogKindResponse, ListIamLogKindError, OvhOpContext>;
+export type ListIamLogSubscriptionError = OvhOpError;
+/** List subscription IDs for a cluster */
+export declare const listIamLogSubscription: API.OperationMethod<ListIamLogSubscriptionRequest, ListIamLogSubscriptionResponse, ListIamLogSubscriptionError, OvhOpContext>;
+export type ListIamPermissionsGroupError = OvhOpError;
+/** Retrieve all permissions groups */
+export declare const listIamPermissionsGroup: API.OperationMethod<ListIamPermissionsGroupRequest, ListIamPermissionsGroupResponse, ListIamPermissionsGroupError, OvhOpContext>;
+export type ListIamPolicyError = OvhOpError;
+/** Retrieve all policies */
+export declare const listIamPolicy: API.OperationMethod<ListIamPolicyRequest, ListIamPolicyResponse, ListIamPolicyError, OvhOpContext>;
+export type ListIamReferenceActionError = OvhOpError;
+/** Retrieve all actions */
+export declare const listIamReferenceAction: API.OperationMethod<ListIamReferenceActionRequest, ListIamReferenceActionResponse, ListIamReferenceActionError, OvhOpContext>;
+export type ListIamReferenceResourceTypeError = OvhOpError;
+/** Retrieve all resource types */
+export declare const listIamReferenceResourceType: API.OperationMethod<ListIamReferenceResourceTypeRequest, ListIamReferenceResourceTypeResponse, ListIamReferenceResourceTypeError, OvhOpContext>;
+export type ListIamResourceError = OvhOpError;
+/** List all resources */
+export declare const listIamResource: API.OperationMethod<ListIamResourceRequest, ListIamResourceResponse, ListIamResourceError, OvhOpContext>;
+export type ListIamResourceGroupError = OvhOpError;
+/** Retrieve all resource groups */
+export declare const listIamResourceGroup: API.OperationMethod<ListIamResourceGroupRequest, ListIamResourceGroupResponse, ListIamResourceGroupError, OvhOpContext>;
+export type PutIamPermissionsGroupError = OvhOpError;
+/** Update a permissions group */
+export declare const putIamPermissionsGroup: API.OperationMethod<PutIamPermissionsGroupRequest, IamPermissionsGroup, PutIamPermissionsGroupError, OvhOpContext>;
+export type PutIamPolicyError = OvhOpError;
+/** Update an existing policy */
+export declare const putIamPolicy: API.OperationMethod<PutIamPolicyRequest, IamPolicyResponse, PutIamPolicyError, OvhOpContext>;
+export type PutIamResourceError = OvhOpError;
+/** Update an existing resource Update an existing resource\ Depending on the update, you will require specific grants on this resource: - Adding tag(s) requires action '$resourceType:apiovh:iam/resource/tag/add' - Removing tag(s) requires action '$resourceType:apiovh:iam/resource/tag/remove' (with $resourceType the type of the updated resource) */
+export declare const putIamResource: API.OperationMethod<PutIamResourceRequest, IamResourceResource, PutIamResourceError, OvhOpContext>;
+export type PutIamResourceGroupError = OvhOpError;
+/** Update an existing resource group */
+export declare const putIamResourceGroup: API.OperationMethod<PutIamResourceGroupRequest, IamGroupResponse, PutIamResourceGroupError, OvhOpContext>;
+//# sourceMappingURL=iam.d.ts.map