Type Alias MRActionsInternal

MRActions: {
    AccessToken: {
        createPersonalAccessToken: {
            headers?: RawAxiosRequestHeaders;
            params: {};
            payload: CreatePATProps;
            return: AccessTokenProp;
        };
        get: {
            params: {
                tokenId: string;
            };
            return: AccessTokenProp;
        };
        getMany: {
            params: QueryParams;
            return: CollectionProp<AccessTokenProp>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<AccessTokenProp>;
        };
        revoke: {
            params: {
                tokenId: string;
            };
            return: AccessTokenProp;
        };
    };
    Agent: {
        generate: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                agentId: string;
            };
            payload: AgentGeneratePayload;
            return: AgentGenerateResponse;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                agentId: string;
            };
            return: AgentProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            return: CollectionProp<AgentProps>;
        };
    };
    AgentRun: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                runId: string;
            };
            return: AgentRunProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                query?: AgentRunQueryOptions;
            };
            return: CollectionProp<AgentRunProps>;
        };
    };
    AiAction: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: CreateAiActionProps;
            return: AiActionProps;
        };
        delete: {
            params: GetSpaceParams & {
                aiActionId: string;
            };
            return: any;
        };
        get: {
            params: GetSpaceParams & {
                aiActionId: string;
            };
            return: AiActionProps;
        };
        getMany: {
            params: GetSpaceParams & {
                query: AiActionQueryOptions;
            };
            return: CollectionProp<AiActionProps>;
        };
        invoke: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                aiActionId: string;
                query?: {
                    status?: "all" | "published";
                };
            };
            payload: AiActionInvocationType;
            return: AiActionInvocationProps;
        };
        publish: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                aiActionId: string;
                version: number;
            };
            return: AiActionProps;
        };
        unpublish: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                aiActionId: string;
            };
            return: AiActionProps;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                aiActionId: string;
            };
            payload: AiActionProps;
            return: AiActionProps;
        };
    };
    AiActionInvocation: {
        get: {
            params: GetSpaceEnvironmentParams & {
                aiActionId: string;
                invocationId: string;
            };
            return: AiActionInvocationProps;
        };
    };
    ApiKey: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: CreateApiKeyProps;
            return: ApiKeyProps;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            payload: CreateApiKeyProps;
            return: ApiKeyProps;
        };
        delete: {
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            return: any;
        };
        get: {
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            return: ApiKeyProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<ApiKeyProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            payload: ApiKeyProps;
            return: ApiKeyProps;
        };
    };
    AppAccessToken: {
        create: {
            params: GetAppInstallationParams;
            payload: CreateAppAccessTokenProps;
            return: AppAccessTokenProps;
        };
    };
    AppAction: {
        create: {
            params: GetAppDefinitionParams;
            payload: CreateAppActionProps;
            return: AppActionProps;
        };
        delete: {
            params: GetAppActionParams;
            return: void;
        };
        get: {
            params: GetAppActionParams;
            return: AppActionProps;
        };
        getMany: {
            params: GetAppDefinitionParams & QueryParams;
            return: CollectionProp<AppActionProps>;
        };
        getManyForEnvironment: {
            params: GetAppActionsForEnvParams & QueryParams;
            return: CollectionProp<AppActionProps>;
        };
        update: {
            params: GetAppActionParams;
            payload: CreateAppActionProps;
            return: AppActionProps;
        };
    };
    AppActionCall: {
        create: {
            params: GetAppActionCallParams;
            payload: CreateAppActionCallProps;
            return: AppActionCallProps;
        };
        createWithResponse: {
            params: CreateWithResponseParams;
            payload: CreateAppActionCallProps;
            return: AppActionCallResponse;
        };
        createWithResult: {
            params: CreateWithResultParams;
            payload: CreateAppActionCallProps;
            return: AppActionCallProps;
        };
        get: {
            params: GetAppActionCallParamsWithId;
            return: AppActionCallProps;
        };
        getCallDetails: {
            params: GetAppActionCallDetailsParams;
            return: AppActionCallResponse;
        };
        getResponse: {
            params: GetAppActionCallParamsWithId;
            return: AppActionCallRawResponseProps;
        };
    };
    AppBundle: {
        create: {
            params: GetAppDefinitionParams;
            payload: CreateAppBundleProps;
            return: AppBundleProps;
        };
        delete: {
            params: GetAppBundleParams;
            return: void;
        };
        get: {
            params: GetAppBundleParams;
            return: AppBundleProps;
        };
        getMany: {
            params: GetAppDefinitionParams & QueryParams;
            return: CollectionProp<AppBundleProps>;
        };
    };
    AppDefinition: {
        create: {
            params: GetOrganizationParams;
            payload: CreateAppDefinitionProps;
            return: AppDefinitionProps;
        };
        delete: {
            params: GetAppDefinitionParams;
            return: any;
        };
        get: {
            params: GetOrganizationParams & {
                appDefinitionId: string;
            };
            return: AppDefinitionProps;
        };
        getInstallationsForOrg: {
            params: GetOrganizationParams & {
                appDefinitionId: string;
            } & SpaceQueryParams;
            return: AppInstallationsForOrganizationProps;
        };
        getMany: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<AppDefinitionProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetAppDefinitionParams;
            payload: AppDefinitionProps;
            return: AppDefinitionProps;
        };
    };
    AppDetails: {
        delete: {
            params: GetAppDefinitionParams;
            return: void;
        };
        get: {
            params: GetAppDefinitionParams;
            return: AppDetailsProps;
        };
        upsert: {
            params: GetAppDefinitionParams;
            payload: CreateAppDetailsProps;
            return: AppDetailsProps;
        };
    };
    AppEventSubscription: {
        delete: {
            params: GetAppDefinitionParams;
            return: void;
        };
        get: {
            params: GetAppDefinitionParams;
            return: AppEventSubscriptionProps;
        };
        upsert: {
            params: GetAppDefinitionParams;
            payload: CreateAppEventSubscriptionProps;
            return: AppEventSubscriptionProps;
        };
    };
    AppInstallation: {
        delete: {
            params: GetAppInstallationParams;
            return: any;
        };
        get: {
            params: GetAppInstallationParams;
            return: AppInstallationProps;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                appDefinitionId: string;
                spaceId?: string;
            };
            return: AppInstallationsForOrganizationProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & PaginationQueryParams;
            return: CollectionProp<AppInstallationProps>;
        };
        upsert: {
            headers?: RawAxiosRequestHeaders;
            params: GetAppInstallationParams & {
                acceptAllTerms?: boolean;
            };
            payload: CreateAppInstallationProps;
            return: AppInstallationProps;
        };
    };
    AppKey: {
        create: {
            params: GetAppDefinitionParams;
            payload: CreateAppKeyProps;
            return: AppKeyProps;
        };
        delete: {
            params: GetAppDefinitionParams & {
                fingerprint: string;
            };
            return: void;
        };
        get: {
            params: GetAppDefinitionParams & {
                fingerprint: string;
            };
            return: AppKeyProps;
        };
        getMany: {
            params: GetAppDefinitionParams & QueryParams;
            return: CollectionProp<AppKeyProps>;
        };
    };
    AppSignedRequest: {
        create: {
            params: GetAppInstallationParams;
            payload: CreateAppSignedRequestProps;
            return: AppSignedRequestProps;
        };
    };
    AppSigningSecret: {
        delete: {
            params: GetAppDefinitionParams;
            return: void;
        };
        get: {
            params: GetAppDefinitionParams;
            return: AppSigningSecretProps;
        };
        upsert: {
            params: GetAppDefinitionParams;
            payload: CreateAppSigningSecretProps;
            return: AppSigningSecretProps;
        };
    };
    AppUpload: {
        create: {
            params: GetOrganizationParams;
            payload: {
                file: string | ArrayBuffer | Stream;
            };
            return: AppUploadProps;
        };
        delete: {
            params: GetAppUploadParams;
            return: void;
        };
        get: {
            params: GetAppUploadParams;
            return: AppUploadProps;
        };
    };
    Asset: {
        archive: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: AssetProps;
        };
        create: {
            params: GetSpaceEnvironmentParams & {
                releaseId?: string;
            };
            payload: CreateAssetProps;
            return: AssetProps;
        };
        createFromFiles: {
            params: GetSpaceEnvironmentParams & {
                releaseId?: string;
                uploadTimeout?: number;
            };
            payload: Omit<AssetFileProp, "sys">;
            return: AssetProps;
        };
        createWithId: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
                releaseId?: string;
            };
            payload: CreateAssetProps;
            return: AssetProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: any;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                assetId: string;
                releaseId?: string;
            } & QueryParams;
            return: AssetProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & QueryParams & {
                releaseId?: string;
            };
            return: CollectionProp<AssetProps>;
        };
        getManyWithCursor: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & CursorBasedParams & {
                releaseId?: string;
            };
            return: CursorPaginatedCollectionProp<AssetProps>;
        };
        getPublished: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<AssetProps>;
        };
        getPublishedWithCursor: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & CursorBasedParams;
            return: CursorPaginatedCollectionProp<AssetProps>;
        };
        processForAllLocales: {
            params: GetSpaceEnvironmentParams & {
                asset: AssetProps;
                options?: AssetProcessingForLocale;
            };
            return: AssetProps;
        };
        processForLocale: {
            params: GetSpaceEnvironmentParams & {
                asset: AssetProps;
                locale: string;
                options?: AssetProcessingForLocale;
            };
            return: AssetProps;
        };
        publish: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            payload: AssetProps;
            return: AssetProps;
        };
        unarchive: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: AssetProps;
        };
        unpublish: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: AssetProps;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                assetId: string;
                releaseId?: string;
            };
            payload: AssetProps;
            return: AssetProps;
        };
    };
    AssetKey: {
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateAssetKeyProps;
            return: AssetKeyProps;
        };
    };
    AutomationDefinition: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: CreateAutomationDefinitionProps;
            return: AutomationDefinitionProps;
        };
        delete: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                automationDefinitionId: string;
                version: number;
            };
            return: void;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                automationDefinitionId: string;
            };
            return: AutomationDefinitionProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                query?: AutomationDefinitionQueryOptions;
            };
            return: CursorPaginatedCollectionProp<AutomationDefinitionProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                automationDefinitionId: string;
            };
            payload: UpdateAutomationDefinitionProps;
            return: AutomationDefinitionProps;
        };
    };
    AutomationExecution: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                automationExecutionId: string;
            };
            return: AutomationExecutionProps;
        };
        getForAutomationDefinition: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                automationDefinitionId: string;
                query?: AutomationExecutionByDefinitionQueryOptions;
            };
            return: CursorPaginatedCollectionProp<AutomationExecutionProps>;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                query?: AutomationExecutionQueryOptions;
            };
            return: CursorPaginatedCollectionProp<AutomationExecutionProps>;
        };
    };
    BulkAction: {
        get: {
            params: GetBulkActionParams;
            return: BulkActionProps;
        };
        getV2: {
            params: GetBulkActionParams;
            return: BulkActionProps<BulkActionV2Payload>;
        };
        publish: {
            params: GetSpaceEnvironmentParams;
            payload: BulkActionPublishPayload;
            return: BulkActionProps<BulkActionPublishPayload>;
        };
        publishV2: {
            params: GetSpaceEnvironmentParams;
            payload: PublishBulkActionV2Payload<"add">;
            return: BulkActionProps<PublishBulkActionV2Payload<"add">>;
        };
        unpublish: {
            params: GetSpaceEnvironmentParams;
            payload: BulkActionUnpublishPayload;
            return: BulkActionProps<BulkActionUnpublishPayload>;
        };
        unpublishV2: {
            params: GetSpaceEnvironmentParams;
            payload: PublishBulkActionV2Payload<"remove"> | UnpublishBulkActionV2Payload;
            return: BulkActionProps<PublishBulkActionV2Payload<"remove"> | UnpublishBulkActionV2Payload>;
        };
        validate: {
            params: GetSpaceEnvironmentParams;
            payload: BulkActionValidatePayload;
            return: BulkActionProps<BulkActionValidatePayload>;
        };
        validateV2: {
            params: GetSpaceEnvironmentParams;
            payload: ValidateBulkActionV2Payload<"add"> | ValidateBulkActionV2Payload<"remove">;
            return: BulkActionProps<ValidateBulkActionV2Payload<"add"> | ValidateBulkActionV2Payload<"remove">>;
        };
    };
    Comment: {
        create: {
            params: CreateCommentParams & PlainTextBodyFormat;
            payload: CreateCommentProps;
            return: CommentProps;
        } | {
            params: CreateCommentParams & RichTextBodyFormat;
            payload: RichTextCommentBodyPayload;
            return: RichTextCommentProps;
        };
        delete: {
            params: DeleteCommentParams;
            return: void;
        };
        get: {
            params: GetCommentParams & PlainTextBodyFormat;
            return: CommentProps;
        } | {
            params: GetCommentParams & RichTextBodyFormat;
            return: RichTextCommentProps;
        };
        getAll: {
            params: GetManyCommentsParams & QueryParams & PlainTextBodyFormat;
            return: CollectionProp<CommentProps>;
        } | {
            params: GetManyCommentsParams & QueryParams & RichTextBodyFormat;
            return: CollectionProp<RichTextCommentProps>;
        };
        getMany: {
            params: GetManyCommentsParams & PlainTextBodyFormat & QueryParams;
            return: CollectionProp<CommentProps>;
        } | {
            params: GetManyCommentsParams & QueryParams & RichTextBodyFormat;
            return: CollectionProp<RichTextCommentProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: UpdateCommentParams;
            payload: UpdateCommentProps;
            return: CommentProps;
        } | {
            headers?: RawAxiosRequestHeaders;
            params: UpdateCommentParams;
            payload: Omit<UpdateCommentProps, "body"> & RichTextCommentBodyPayload;
            return: RichTextCommentProps;
        };
    };
    ComponentType: {
        getMany: {
            params: GetSpaceEnvironmentParams & {
                query: ComponentTypeQueryOptions;
            };
            return: CollectionProp<ComponentTypeProps>;
        };
    };
    Concept: {
        create: {
            params: GetOrganizationParams;
            payload: CreateConceptProps;
            return: ConceptProps;
        };
        createWithId: {
            params: GetConceptParams;
            payload: CreateConceptProps;
            return: ConceptProps;
        };
        delete: {
            params: DeleteConceptParams;
            return: void;
        };
        get: {
            params: GetConceptParams;
            return: ConceptProps;
        };
        getAncestors: {
            params: GetConceptDescendantsParams;
            return: CursorPaginatedCollectionProp<ConceptProps>;
        };
        getDescendants: {
            params: GetConceptDescendantsParams;
            return: CursorPaginatedCollectionProp<ConceptProps>;
        };
        getMany: {
            params: GetManyConceptParams;
            return: CursorPaginatedCollectionProp<ConceptProps>;
        };
        getTotal: {
            params: GetOrganizationParams;
            return: {
                total: number;
            };
        };
        patch: {
            params: UpdateConceptParams;
            payload: OpPatch[];
            return: ConceptProps;
        };
        update: {
            params: UpdateConceptParams;
            payload: CreateConceptProps;
            return: ConceptProps;
        };
    };
    ConceptScheme: {
        create: {
            params: GetOrganizationParams;
            payload: CreateConceptSchemeProps;
            return: ConceptSchemeProps;
        };
        createWithId: {
            params: GetConceptSchemeParams;
            payload: CreateConceptSchemeProps;
            return: ConceptSchemeProps;
        };
        delete: {
            params: DeleteConceptSchemeParams;
            return: void;
        };
        get: {
            params: GetConceptSchemeParams;
            return: ConceptSchemeProps;
        };
        getMany: {
            params: GetManyConceptSchemeParams;
            return: CursorPaginatedCollectionProp<ConceptSchemeProps>;
        };
        getTotal: {
            params: GetOrganizationParams;
            return: {
                total: number;
            };
        };
        patch: {
            params: UpdateConceptSchemeParams;
            payload: OpPatch[];
            return: ConceptSchemeProps;
        };
        update: {
            params: UpdateConceptSchemeParams;
            payload: CreateConceptSchemeProps;
            return: ConceptSchemeProps;
        };
    };
    ContentSemanticsIndex: {
        create: {
            params: GetOrganizationParams;
            payload: CreateContentSemanticsIndexProps;
            return: ContentSemanticsIndexProps;
        };
        delete: {
            params: GetContentSemanticsIndexParams;
            return: void;
        };
        get: {
            params: GetContentSemanticsIndexParams;
            return: ContentSemanticsIndexProps;
        };
        getMany: {
            params: GetManyContentSemanticsIndexParams;
            return: ContentSemanticsIndexCollectionProps;
        };
        getManyForEnvironment: {
            params: GetManyContentSemanticsIndexForEnvironmentParams;
            return: ContentSemanticsIndexCollectionProps;
        };
    };
    ContentType: {
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateContentTypeProps;
            return: ContentTypeProps;
        };
        createWithId: {
            params: GetContentTypeParams;
            payload: CreateContentTypeProps;
            return: ContentTypeProps;
        };
        delete: {
            params: GetContentTypeParams;
            return: any;
        };
        get: {
            params: GetContentTypeParams & QueryParams;
            return: ContentTypeProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<ContentTypeProps>;
        };
        getManyWithCursor: {
            params: GetSpaceEnvironmentParams & CursorBasedParams;
            return: CursorPaginatedCollectionProp<ContentTypeProps>;
        };
        publish: {
            params: GetContentTypeParams;
            payload: ContentTypeProps;
            return: ContentTypeProps;
        };
        unpublish: {
            params: GetContentTypeParams;
            return: ContentTypeProps;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetContentTypeParams;
            payload: ContentTypeProps;
            return: ContentTypeProps;
        };
    };
    EditorInterface: {
        get: {
            params: GetEditorInterfaceParams;
            return: EditorInterfaceProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<EditorInterfaceProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetEditorInterfaceParams;
            payload: EditorInterfaceProps;
            return: EditorInterfaceProps;
        };
    };
    Entry: {
        archive: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: EntryProps<any>;
        };
        create: {
            params: GetSpaceEnvironmentParams & {
                contentTypeId: string;
                releaseId?: string;
            };
            payload: CreateEntryProps<any>;
            return: EntryProps<any>;
        };
        createWithId: {
            params: GetSpaceEnvironmentParams & {
                contentTypeId: string;
                entryId: string;
                releaseId?: string;
            };
            payload: CreateEntryProps<any>;
            return: EntryProps<any>;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: any;
        };
        get: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                releaseId?: string;
            } & QueryParams;
            return: EntryProps<any>;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams & {
                releaseId?: string;
            };
            return: CollectionProp<EntryProps<any>>;
        };
        getManyWithCursor: {
            params: GetSpaceEnvironmentParams & CursorBasedParams & {
                releaseId?: string;
            };
            return: CursorPaginatedCollectionProp<EntryProps<any>>;
        };
        getPublished: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<EntryProps<any>>;
        };
        getPublishedWithCursor: {
            params: GetSpaceEnvironmentParams & CursorBasedParams;
            return: CursorPaginatedCollectionProp<EntryProps<any>>;
        };
        patch: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                releaseId?: string;
                version: number;
            };
            payload: OpPatch[];
            return: EntryProps<any>;
        };
        publish: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            payload: EntryProps<any>;
            return: EntryProps<any>;
        };
        references: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                include?: number;
            };
            return: EntryReferenceProps;
        };
        unarchive: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: EntryProps<any>;
        };
        unpublish: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: EntryProps<any>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                releaseId?: string;
            };
            payload: EntryProps<any>;
            return: EntryProps<any>;
        };
    };
    Environment: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: Partial<Pick<EnvironmentProps, "name">>;
            return: EnvironmentProps;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                sourceEnvironmentId?: string;
            };
            payload: CreateEnvironmentProps;
            return: EnvironmentProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams;
            return: any;
        };
        get: {
            params: GetSpaceEnvironmentParams;
            return: EnvironmentProps;
        };
        getMany: {
            params: GetSpaceParams & PaginationQueryParams;
            return: CollectionProp<EnvironmentProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: EnvironmentProps;
            return: EnvironmentProps;
        };
    };
    EnvironmentAlias: {
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvAliasParams;
            payload: CreateEnvironmentAliasProps;
            return: EnvironmentAliasProps;
        };
        delete: {
            params: GetSpaceEnvAliasParams;
            return: any;
        };
        get: {
            params: GetSpaceEnvAliasParams;
            return: EnvironmentAliasProps;
        };
        getMany: {
            params: GetSpaceParams & PaginationQueryParams;
            return: CollectionProp<EnvironmentAliasProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvAliasParams;
            payload: EnvironmentAliasProps;
            return: EnvironmentAliasProps;
        };
    };
    EnvironmentTemplate: {
        create: {
            params: GetOrganizationParams;
            payload: CreateEnvironmentTemplateProps;
            return: EnvironmentTemplateProps;
        };
        delete: {
            params: GetEnvironmentTemplateParams;
            return: void;
        };
        disconnect: {
            params: EnvironmentTemplateParams;
            return: void;
        };
        get: {
            params: GetEnvironmentTemplateParams & {
                query?: {
                    select?: string;
                };
                version?: number;
            };
            return: EnvironmentTemplateProps;
        };
        getMany: {
            params: GetOrganizationParams & {
                query?: BasicCursorPaginationOptions & {
                    forTemplatedSpaces?: boolean;
                    select?: string;
                };
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateProps>;
        };
        install: {
            params: EnvironmentTemplateParams;
            payload: CreateEnvironmentTemplateInstallationProps;
            return: EnvironmentTemplateInstallationProps;
        };
        update: {
            params: GetEnvironmentTemplateParams;
            payload: EnvironmentTemplateProps;
            return: EnvironmentTemplateProps;
        };
        validate: {
            params: EnvironmentTemplateParams & {
                version?: number;
            };
            payload: ValidateEnvironmentTemplateInstallationProps;
            return: EnvironmentTemplateValidationProps;
        };
        versions: {
            params: GetEnvironmentTemplateParams & {
                query?: BasicCursorPaginationOptions & {
                    installable?: boolean;
                    select?: string;
                };
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateProps>;
        };
        versionUpdate: {
            params: GetEnvironmentTemplateParams & {
                version: number;
            };
            payload: {
                versionDescription: string;
                versionName: string;
            };
            return: EnvironmentTemplateProps;
        };
    };
    EnvironmentTemplateInstallation: {
        getForEnvironment: {
            params: BasicCursorPaginationOptions & EnvironmentTemplateParams & {
                installationId?: string;
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>;
        };
        getMany: {
            params: BasicCursorPaginationOptions & {
                environmentId?: string;
                environmentTemplateId: string;
                latestOnly?: boolean;
                organizationId: string;
                spaceId?: string;
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>;
        };
    };
    Extension: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: CreateUIExtensionProps;
            return: UIExtensionProps;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetExtensionParams;
            payload: CreateUIExtensionProps;
            return: UIExtensionProps;
        };
        delete: {
            params: GetExtensionParams;
            return: any;
        };
        get: {
            params: GetExtensionParams & QueryParams;
            return: UIExtensionProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<UIExtensionProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetExtensionParams;
            payload: UIExtensionProps;
            return: UIExtensionProps;
        };
    };
    Function: {
        get: {
            params: GetFunctionParams;
            return: FunctionProps;
        };
        getMany: {
            params: GetManyFunctionParams;
            return: CollectionProp<FunctionProps>;
        };
        getManyForEnvironment: {
            params: GetFunctionForEnvParams;
            return: CollectionProp<FunctionProps>;
        };
    };
    FunctionLog: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetFunctionLogParams;
            return: FunctionLogProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetManyFunctionLogParams;
            return: CollectionProp<FunctionLogProps>;
        };
    };
    Http: {
        delete: {
            params: {
                config?: RawAxiosRequestConfig;
                url: string;
            };
            return: any;
        };
        get: {
            params: {
                config?: RawAxiosRequestConfig;
                url: string;
            };
            return: any;
        };
        patch: {
            params: {
                config?: RawAxiosRequestConfig;
                url: string;
            };
            payload: any;
            return: any;
        };
        post: {
            params: {
                config?: RawAxiosRequestConfig;
                url: string;
            };
            payload: any;
            return: any;
        };
        put: {
            params: {
                config?: RawAxiosRequestConfig;
                url: string;
            };
            payload: any;
            return: any;
        };
        request: {
            params: {
                config?: RawAxiosRequestConfig;
                url: string;
            };
            return: any;
        };
    };
    Locale: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: CreateLocaleProps;
            return: LocaleProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                localeId: string;
            };
            return: any;
        };
        get: {
            params: GetSpaceEnvironmentParams & {
                localeId: string;
            };
            return: LocaleProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<LocaleProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                localeId: string;
            };
            payload: LocaleProps;
            return: LocaleProps;
        };
    };
    OAuthApplication: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetUserParams;
            payload: CreateOAuthApplicationProps;
            return: OAuthApplicationProps;
        };
        delete: {
            params: GetOAuthApplicationParams;
            return: void;
        };
        get: {
            params: GetOAuthApplicationParams;
            return: OAuthApplicationProps;
        };
        getManyForUser: {
            params: GetUserParams & QueryParams;
            return: CursorPaginatedCollectionProp<OAuthApplicationProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetOAuthApplicationParams;
            payload: UpdateOAuthApplicationProps;
            return: OAuthApplicationProps;
        };
    };
    Organization: {
        get: {
            params: GetOrganizationParams;
            return: OrganizationProps;
        };
        getMany: {
            params: PaginationQueryParams;
            return: CollectionProp<OrganizationProps>;
        };
    };
    OrganizationInvitation: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: {
                organizationId: string;
            };
            payload: CreateOrganizationInvitationProps;
            return: OrganizationInvitationProps;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: {
                invitationId: string;
                organizationId: string;
            };
            return: OrganizationInvitationProps;
        };
    };
    OrganizationMembership: {
        delete: {
            params: GetOrganizationMembershipParams;
            return: any;
        };
        get: {
            params: GetOrganizationMembershipParams;
            return: OrganizationMembershipProps;
        };
        getMany: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<OrganizationMembershipProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetOrganizationMembershipParams;
            payload: OrganizationMembershipProps;
            return: OrganizationMembershipProps;
        };
    };
    PersonalAccessToken: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: {};
            payload: CreatePersonalAccessTokenProps;
            return: PersonalAccessTokenProps;
        };
        get: {
            params: {
                tokenId: string;
            };
            return: PersonalAccessTokenProps;
        };
        getMany: {
            params: QueryParams;
            return: CollectionProp<PersonalAccessTokenProps>;
        };
        revoke: {
            params: {
                tokenId: string;
            };
            return: PersonalAccessTokenProps;
        };
    };
    PreviewApiKey: {
        get: {
            params: GetSpaceParams & {
                previewApiKeyId: string;
            };
            return: PreviewApiKeyProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<PreviewApiKeyProps>;
        };
    };
    Release: {
        archive: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseProps;
        };
        create: {
            params: ReleaseEnvironmentParams;
            payload: ReleasePayload | ReleasePayloadV2;
            return: ReleaseProps;
        };
        delete: {
            params: GetReleaseParams;
            return: void;
        };
        get: {
            params: GetReleaseParams;
            return: ReleaseProps;
        };
        publish: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseActionProps<"publish">;
        };
        query: {
            params: ReleaseEnvironmentParams & {
                query?: ReleaseQueryOptions;
            };
            return: CollectionProp<ReleaseProps>;
        };
        unarchive: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseProps;
        };
        unpublish: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseActionProps<"unpublish">;
        };
        update: {
            params: GetReleaseParams & {
                version: number;
            };
            payload: ReleasePayload | ReleasePayloadV2;
            return: ReleaseProps;
        };
        validate: {
            params: GetReleaseParams;
            payload?: ReleaseValidatePayload;
            return: ReleaseActionProps<"validate">;
        };
    };
    ReleaseAction: {
        get: {
            params: GetReleaseParams & {
                actionId: string;
            };
            return: ReleaseAction;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & {
                query?: ReleaseActionQueryOptions;
            };
            return: Collection<ReleaseAction, ReleaseActionProps>;
        };
        queryForRelease: {
            params: GetReleaseParams & {
                query?: ReleaseActionQueryOptions;
            };
            return: Collection<ReleaseAction, ReleaseActionProps>;
        };
    };
    ReleaseAsset: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: CreateReleaseAssetParams & QueryParams;
            payload: CreateAssetProps;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
        createFromFiles: {
            headers?: RawAxiosRequestHeaders;
            params: CreateWithFilesReleaseAssetParams & QueryParams;
            payload: Omit<AssetFileProp, "sys">;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: CreateWithIdReleaseAssetParams & QueryParams;
            payload: CreateAssetProps;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetReleaseAssetParams & QueryParams;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetManyReleaseAssetParams & QueryParams;
            return: CollectionProp<AssetProps<{
                release: Link<"Release">;
            }>>;
        };
        processForAllLocales: {
            params: ProcessForAllLocalesReleaseAssetParams;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
        processForLocale: {
            params: ProcessForLocaleReleaseAssetParams;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: UpdateReleaseAssetParams & QueryParams;
            payload: AssetProps;
            return: AssetProps<{
                release: Link<"Release">;
            }>;
        };
    };
    ReleaseEntry: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: CreateReleaseEntryParams & QueryParams;
            payload: CreateEntryProps<any>;
            return: EntryProps<any, {
                release: Link<"Release">;
            }>;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: CreateReleaseEntryParams & {
                entryId: string;
            } & QueryParams;
            payload: CreateEntryProps<any>;
            return: EntryProps<any, {
                release: Link<"Release">;
            }>;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetReleaseEntryParams & QueryParams;
            return: EntryProps<any, {
                release: Link<"Release">;
            }>;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetManyReleaseEntryParams & QueryParams;
            return: CollectionProp<EntryProps<any, {
                release: Link<"Release">;
            }>>;
        };
        patch: {
            headers?: RawAxiosRequestHeaders;
            params: PatchReleaseEntryParams & QueryParams;
            payload: OpPatch[];
            return: EntryProps<any, {
                release: Link<"Release">;
            }>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: UpdateReleaseEntryParams & QueryParams;
            payload: EntryProps<any>;
            return: EntryProps<any, {
                release: Link<"Release">;
            }>;
        };
    };
    Resource: {
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetResourceParams & {
                query?: ResourceQueryOptions;
            };
            return: CursorPaginatedCollectionProp<ResourceProps>;
        };
    };
    ResourceProvider: {
        delete: {
            params: GetResourceProviderParams;
            return: any;
        };
        get: {
            params: GetResourceProviderParams;
            return: ResourceProviderProps;
        };
        upsert: {
            headers?: RawAxiosRequestHeaders;
            params: GetResourceProviderParams;
            payload: UpsertResourceProviderProps;
            return: ResourceProviderProps;
        };
    };
    ResourceType: {
        delete: {
            params: GetResourceTypeParams;
            return: any;
        };
        get: {
            params: GetResourceTypeParams;
            return: ResourceTypeProps;
        };
        getForEnvironment: {
            params: GetSpaceEnvironmentParams & {
                query?: BasicCursorPaginationOptions;
            };
            return: CursorPaginatedCollectionProp<SpaceEnvResourceTypeProps>;
        };
        getMany: {
            params: Omit<GetResourceTypeParams, "resourceTypeId">;
            return: CollectionProp<ResourceTypeProps>;
        };
        upsert: {
            headers?: RawAxiosRequestHeaders;
            params: GetResourceTypeParams;
            payload: UpsertResourceTypeProps;
            return: ResourceTypeProps;
        };
    };
    Role: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: CreateRoleProps;
            return: RoleProps;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                roleId: string;
            };
            payload: CreateRoleProps;
            return: RoleProps;
        };
        delete: {
            params: GetSpaceParams & {
                roleId: string;
            };
            return: any;
        };
        get: {
            params: GetSpaceParams & {
                roleId: string;
            };
            return: RoleProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<RoleProps>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<RoleProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                roleId: string;
            };
            payload: RoleProps;
            return: RoleProps;
        };
    };
    ScheduledAction: {
        create: {
            params: GetSpaceParams;
            payload: Omit<ScheduledActionProps, "sys">;
            return: ScheduledActionProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                scheduledActionId: string;
            };
            return: any;
        };
        get: {
            params: GetSpaceParams & {
                environmentId: string;
                scheduledActionId: string;
            };
            return: ScheduledActionProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<ScheduledActionProps>;
        };
        update: {
            params: GetSpaceParams & {
                scheduledActionId: string;
                version: number;
            };
            payload: Omit<ScheduledActionProps, "sys">;
            return: ScheduledActionProps;
        };
    };
    SemanticDuplicates: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: GetSemanticDuplicatesProps;
            return: SemanticDuplicatesProps;
        };
    };
    SemanticRecommendations: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: GetSemanticRecommendationsProps;
            return: SemanticRecommendationsProps;
        };
    };
    SemanticReferenceSuggestions: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: GetSemanticReferenceSuggestionsProps;
            return: SemanticReferenceSuggestionsProps;
        };
    };
    SemanticSearch: {
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams;
            payload: GetSemanticSearchProps;
            return: SemanticSearchProps;
        };
    };
    SemanticSettings: {
        get: {
            params: GetOrganizationParams;
            return: ContentSemanticsSettingsProps;
        };
    };
    Snapshot: {
        getForContentType: {
            params: GetSnapshotForContentTypeParams & {
                snapshotId: string;
            };
            return: SnapshotProps<ContentTypeProps>;
        };
        getForEntry: {
            params: GetSnapshotForEntryParams & {
                snapshotId: string;
            };
            return: SnapshotProps<Omit<EntryProps<any>, "metadata">>;
        };
        getManyForContentType: {
            params: GetSnapshotForContentTypeParams & QueryParams;
            return: CollectionProp<SnapshotProps<ContentTypeProps>>;
        };
        getManyForEntry: {
            params: GetSnapshotForEntryParams & QueryParams;
            return: CollectionProp<SnapshotProps<Omit<EntryProps<any>, "metadata">>>;
        };
    };
    Space: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: {
                organizationId?: string;
            };
            payload: Omit<SpaceProps, "sys">;
            return: any;
        };
        delete: {
            params: GetSpaceParams;
            return: void;
        };
        get: {
            params: GetSpaceParams;
            return: SpaceProps;
        };
        getMany: {
            params: QueryParams;
            return: CollectionProp<SpaceProps>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<SpaceProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: SpaceProps;
            return: SpaceProps;
        };
    };
    SpaceMember: {
        get: {
            params: GetSpaceParams & {
                spaceMemberId: string;
            };
            return: SpaceMemberProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<SpaceMemberProps>;
        };
    };
    SpaceMembership: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: CreateSpaceMembershipProps;
            return: SpaceMembershipProps;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceMembershipProps;
            payload: CreateSpaceMembershipProps;
            return: SpaceMembershipProps;
        };
        delete: {
            params: GetSpaceMembershipProps;
            return: any;
        };
        get: {
            params: GetSpaceMembershipProps;
            return: SpaceMembershipProps;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                spaceMembershipId: string;
            };
            return: SpaceMembershipProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<SpaceMembershipProps>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<SpaceMembershipProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceMembershipProps;
            payload: SpaceMembershipProps;
            return: SpaceMembershipProps;
        };
    };
    Tag: {
        createWithId: {
            params: GetTagParams;
            payload: CreateTagProps;
            return: TagProps;
        };
        delete: {
            params: DeleteTagParams;
            return: any;
        };
        get: {
            params: GetTagParams;
            return: TagProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<TagProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetTagParams;
            payload: UpdateTagProps;
            return: TagProps;
        };
    };
    Task: {
        create: {
            params: CreateTaskParams;
            payload: CreateTaskProps;
            return: TaskProps;
        };
        delete: {
            params: DeleteTaskParams;
            return: void;
        };
        get: {
            params: GetTaskParams;
            return: TaskProps;
        };
        getAll: {
            params: GetEntryParams & QueryParams;
            return: CollectionProp<TaskProps>;
        };
        getMany: {
            params: GetEntryParams & QueryParams;
            return: CollectionProp<TaskProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: UpdateTaskParams;
            payload: UpdateTaskProps;
            return: TaskProps;
        };
    };
    Team: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetOrganizationParams;
            payload: CreateTeamProps;
            return: any;
        };
        delete: {
            params: GetTeamParams;
            return: any;
        };
        get: {
            params: GetTeamParams;
            return: TeamProps;
        };
        getMany: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<TeamProps>;
        };
        getManyForSpace: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<TeamProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetTeamParams;
            payload: TeamProps;
            return: TeamProps;
        };
    };
    TeamMembership: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetTeamParams;
            payload: CreateTeamMembershipProps;
            return: TeamMembershipProps;
        };
        delete: {
            params: GetTeamMembershipParams;
            return: any;
        };
        get: {
            params: GetTeamMembershipParams;
            return: TeamMembershipProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<TeamMembershipProps>;
        };
        getManyForTeam: {
            params: GetTeamParams & QueryParams;
            return: CollectionProp<TeamMembershipProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetTeamMembershipParams;
            payload: TeamMembershipProps;
            return: TeamMembershipProps;
        };
    };
    TeamSpaceMembership: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams & {
                teamId: string;
            };
            payload: CreateTeamSpaceMembershipProps;
            return: TeamSpaceMembershipProps;
        };
        delete: {
            params: GetTeamSpaceMembershipParams;
            return: any;
        };
        get: {
            params: GetTeamSpaceMembershipParams;
            return: TeamSpaceMembershipProps;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                teamSpaceMembershipId: string;
            };
            return: TeamSpaceMembershipProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<TeamSpaceMembershipProps>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams & {
                teamId?: string;
            };
            return: CollectionProp<TeamSpaceMembershipProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetTeamSpaceMembershipParams;
            payload: TeamSpaceMembershipProps;
            return: TeamSpaceMembershipProps;
        };
    };
    UIConfig: {
        get: {
            params: GetUIConfigParams;
            return: UIConfigProps;
        };
        update: {
            params: GetUIConfigParams;
            payload: UIConfigProps;
            return: UIConfigProps;
        };
    };
    Upload: {
        create: {
            params: GetSpaceEnvironmentParams;
            payload: {
                file: string | ArrayBuffer | Stream;
            };
            return: any;
        };
        delete: {
            params: GetSpaceEnvironmentUploadParams;
            return: any;
        };
        get: {
            params: GetSpaceEnvironmentUploadParams;
            return: any;
        };
    };
    UploadCredential: {
        create: {
            params: GetSpaceEnvironmentParams;
            return: any;
        };
    };
    Usage: {
        getManyForOrganization: {
            params: {
                organizationId: string;
            } & QueryParams;
            return: CollectionProp<UsageProps>;
        };
        getManyForSpace: {
            params: {
                organizationId: string;
            } & QueryParams;
            return: CollectionProp<UsageProps>;
        };
    };
    User: {
        getCurrent: {
            params?: QueryParams;
            return: any;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                userId: string;
            };
            return: UserProps;
        };
        getForSpace: {
            params: GetSpaceParams & {
                userId: string;
            };
            return: UserProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<UserProps>;
        };
        getManyForSpace: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<UserProps>;
        };
    };
    UserUIConfig: {
        get: {
            params: GetUserUIConfigParams;
            return: UserUIConfigProps;
        };
        update: {
            params: GetUserUIConfigParams;
            payload: UserUIConfigProps;
            return: UserUIConfigProps;
        };
    };
    Webhook: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceParams;
            payload: CreateWebhooksProps;
            return: WebhookProps;
        };
        createWithId: {
            headers?: RawAxiosRequestHeaders;
            params: GetWebhookParams;
            payload: CreateWebhooksProps;
            return: WebhookProps;
        };
        delete: {
            params: GetWebhookParams;
            return: void;
        };
        deleteRetryPolicy: {
            params: GetSpaceParams;
            return: void;
        };
        deleteSigningSecret: {
            params: GetSpaceParams;
            return: void;
        };
        get: {
            params: GetWebhookParams;
            return: WebhookProps;
        };
        getCallDetails: {
            params: GetWebhookCallDetailsUrl;
            return: WebhookCallDetailsProps;
        };
        getHealthStatus: {
            params: GetWebhookParams;
            return: WebhookHealthProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<WebhookProps>;
        };
        getManyCallDetails: {
            params: GetWebhookParams & QueryParams;
            return: CollectionProp<WebhookCallOverviewProps>;
        };
        getRetryPolicy: {
            params: GetSpaceParams;
            return: WebhookRetryPolicyProps;
        };
        getSigningSecret: {
            params: GetSpaceParams;
            return: WebhookSigningSecretProps;
        };
        update: {
            params: GetWebhookParams;
            payload: WebhookProps;
            return: WebhookProps;
        };
        upsertRetryPolicy: {
            params: GetSpaceParams;
            payload: WebhookRetryPolicyPayload;
            return: WebhookRetryPolicyProps;
        };
        upsertSigningSecret: {
            params: GetSpaceParams;
            payload: UpsertWebhookSigningSecretPayload;
            return: WebhookSigningSecretProps;
        };
    };
    Workflow: {
        complete: {
            headers?: RawAxiosRequestHeaders;
            params: CompleteWorkflowParams;
            return: void;
        };
        create: {
            headers?: RawAxiosRequestHeaders;
            params: CreateWorkflowParams;
            payload: CreateWorkflowProps;
            return: WorkflowProps;
        };
        delete: {
            headers?: RawAxiosRequestHeaders;
            params: DeleteWorkflowParams;
            return: void;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetWorkflowParams;
            return: WorkflowProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                query?: WorkflowQueryOptions;
            };
            return: CollectionProp<WorkflowProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetWorkflowParams;
            payload: WorkflowProps;
            return: WorkflowProps;
        };
    };
    WorkflowDefinition: {
        create: {
            headers?: RawAxiosRequestHeaders;
            params: CreateWorkflowDefinitionParams;
            payload: CreateWorkflowDefinitionProps;
            return: WorkflowDefinitionProps;
        };
        delete: {
            headers?: RawAxiosRequestHeaders;
            params: DeleteWorkflowDefinitionParams;
            return: void;
        };
        get: {
            headers?: RawAxiosRequestHeaders;
            params: GetWorkflowDefinitionParams;
            return: WorkflowDefinitionProps;
        };
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                query?: WorkflowDefinitionQueryOptions;
            };
            return: CollectionProp<WorkflowDefinitionProps>;
        };
        update: {
            headers?: RawAxiosRequestHeaders;
            params: GetWorkflowDefinitionParams;
            payload: WorkflowDefinitionProps;
            return: WorkflowDefinitionProps;
        };
    };
    WorkflowsChangelog: {
        getMany: {
            headers?: RawAxiosRequestHeaders;
            params: GetSpaceEnvironmentParams & {
                query: WorkflowsChangelogQueryOptions;
            };
            return: CollectionProp<WorkflowsChangelogEntryProps>;
        };
    };
}

Settings

Member Visibility