Type Alias PlainClientAPI

PlainClientAPI: {
    accessToken: {
        createPersonalAccessToken(rawData: CreatePATProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<AccessTokenProp>;
        get(params: OptionalDefaults<{
            tokenId: string;
        }>): Promise<AccessTokenProp>;
        getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<AccessTokenProp>>;
        getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<AccessTokenProp>>;
        revoke(params: OptionalDefaults<{
            tokenId: string;
        }>): Promise<AccessTokenProp>;
    };
    agent: AgentPlainClientAPI;
    agentRun: AgentRunPlainClientAPI;
    aiAction: AiActionPlainClientAPI;
    aiActionInvocation: AiActionInvocationPlainClientAPI;
    apiKey: {
        create(params: OptionalDefaults<GetSpaceParams>, data: CreateApiKeyProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<ApiKeyProps>;
        createWithId(params: OptionalDefaults<GetSpaceParams & {
            apiKeyId: string;
        }>, data: CreateApiKeyProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<ApiKeyProps>;
        delete(params: OptionalDefaults<GetSpaceParams & {
            apiKeyId: string;
        }>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceParams & {
            apiKeyId: string;
        }>): Promise<ApiKeyProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<ApiKeyProps>>;
        update(params: OptionalDefaults<GetSpaceParams & {
            apiKeyId: string;
        }>, rawData: ApiKeyProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<ApiKeyProps>;
    };
    appAccessToken: AppAccessTokenPlainClientAPI;
    appAction: AppActionPlainClientAPI;
    appActionCall: AppActionCallPlainClientAPI;
    appBundle: AppBundlePlainClientAPI;
    appDefinition: AppDefinitionPlainClientAPI;
    appDetails: AppDetailsPlainClientAPI;
    appEventSubscription: AppEventSubscriptionPlainClientAPI;
    appInstallation: AppInstallationPlainClientAPI;
    appKey: AppKeyPlainClientAPI;
    appSignedRequest: AppSignedRequestPlainClientAPI;
    appSigningSecret: AppSigningSecretPlainClientAPI;
    appUpload: AppUploadPlainClientAPI;
    asset: {
        archive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<AssetProps>;
        create(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId?: string;
        }>, rawData: CreateAssetProps): Promise<AssetProps>;
        createFromFiles(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId?: string;
        }>, data: Omit<AssetFileProp, "sys">): Promise<AssetProps>;
        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
            releaseId?: string;
        }>, rawData: CreateAssetProps): Promise<AssetProps>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
            releaseId?: string;
        } & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<AssetProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams & {
            releaseId?: string;
        }>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CollectionProp<AssetProps>>;
        getManyWithCursor(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorPaginationXORParams & {
            releaseId?: string;
        }>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<AssetProps>>;
        getPublished(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CollectionProp<AssetProps>>;
        getPublishedWithCursor(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorPaginationXORParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<AssetProps>>;
        processForAllLocales(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId?: string;
        }>, asset: AssetProps, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>;
        processForLocale(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId?: string;
        }>, asset: AssetProps, locale: string, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>;
        publish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
            locales?: string[];
        }>, rawData: AssetProps): Promise<AssetProps>;
        unarchive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<AssetProps>;
        unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
            locales?: string[];
        }>, rawData?: AssetProps): Promise<AssetProps>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
            releaseId?: string;
        }>, rawData: AssetProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<AssetProps>;
    };
    assetKey: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateAssetKeyProps): Promise<AssetKeyProps>;
    };
    automationDefinition: AutomationDefinitionPlainClientAPI;
    automationExecution: AutomationExecutionPlainClientAPI;
    bulkAction: {
        get<T>(params: GetBulkActionParams): Promise<BulkActionProps<T>>;
        getV2(params: GetBulkActionParams): Promise<BulkActionProps<BulkActionV2Payload>>;
        publish(params: GetSpaceEnvironmentParams, payload: BulkActionPublishPayload): Promise<BulkActionProps<BulkActionPublishPayload>>;
        publishV2(params: GetSpaceEnvironmentParams, payload: PublishBulkActionV2Payload<"add">): Promise<BulkActionProps<PublishBulkActionV2Payload<"add">>>;
        unpublish(params: GetSpaceEnvironmentParams, payload: BulkActionUnpublishPayload): Promise<BulkActionProps<BulkActionUnpublishPayload>>;
        unpublishV2(params: GetSpaceEnvironmentParams, payload: PublishBulkActionV2Payload<"remove"> | UnpublishBulkActionV2Payload): Promise<BulkActionProps<PublishBulkActionV2Payload<"remove"> | UnpublishBulkActionV2Payload>>;
        validate(params: GetSpaceEnvironmentParams, payload: BulkActionValidatePayload): Promise<BulkActionProps<BulkActionValidatePayload>>;
        validateV2(params: GetSpaceEnvironmentParams, payload: ValidateBulkActionV2Payload<"add"> | ValidateBulkActionV2Payload<"remove">): Promise<BulkActionProps<ValidateBulkActionV2Payload<"add"> | ValidateBulkActionV2Payload<"remove">>>;
    };
    comment: CommentPlainClientAPI;
    component: ComponentPlainClientAPI;
    componentType: ComponentTypePlainClientAPI;
    concept: ConceptPlainClientAPI;
    conceptScheme: ConceptSchemePlainClientAPI;
    contentSemanticsIndex: ContentSemanticsIndexPlainClientAPI;
    contentType: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: {
            description?: string;
            displayField?: string;
            fields: ContentFields[];
            metadata?: ContentTypeMetadata;
            name: string;
        }): Promise<ContentTypeProps>;
        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
        }>, rawData: {
            description?: string;
            displayField?: string;
            fields: ContentFields[];
            metadata?: ContentTypeMetadata;
            name: string;
        }): Promise<ContentTypeProps>;
        delete(params: OptionalDefaults<GetContentTypeParams>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
        } & QueryParams>): Promise<ContentTypeProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<ContentTypeProps>>;
        getManyWithCursor(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorPaginationXORParams>): Promise<CursorPaginatedCollectionProp<ContentTypeProps>>;
        omitAndDeleteField(params: OptionalDefaults<GetContentTypeParams>, contentType: ContentTypeProps, fieldId: string): Promise<ContentTypeProps>;
        publish(params: OptionalDefaults<GetContentTypeParams>, rawData: ContentTypeProps): Promise<ContentTypeProps>;
        unpublish(params: OptionalDefaults<GetContentTypeParams>): Promise<ContentTypeProps>;
        update(params: OptionalDefaults<GetContentTypeParams>, rawData: ContentTypeProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<ContentTypeProps>;
    };
    dataAssembly: DataAssemblyPlainClientAPI;
    designToken: DesignTokenPlainClientAPI;
    editorInterface: EditorInterfacePlainClientAPI;
    entry: {
        archive<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>): Promise<EntryProps<T>>;
        create<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
            releaseId?: string;
        }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>;
        createWithId<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
            entryId: string;
            releaseId?: string;
        }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>): Promise<any>;
        get<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
            releaseId?: string;
        }>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EntryProps<T>>;
        getMany<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams & {
            releaseId?: string;
        }>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CollectionProp<EntryProps<T>>>;
        getManyWithCursor<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorPaginationXORParams & {
            releaseId?: string;
        }>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<EntryProps<T>>>;
        getPublished<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CollectionProp<EntryProps<T>>>;
        getPublishedWithCursor<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorPaginationXORParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<EntryProps<T>>>;
        patch<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
            releaseId?: string;
            version: number;
        }>, rawData: OpPatch[], headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EntryProps<T>>;
        publish<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
            locales?: string[];
        }>, rawData: EntryProps<T>): Promise<EntryProps<T>>;
        references(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
            include?: number;
        }>): Promise<EntryReferenceProps>;
        unarchive<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>): Promise<EntryProps<T>>;
        unpublish<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
            locales?: string[];
        }>, rawData?: EntryProps<T>): Promise<EntryProps<T>>;
        update<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
            releaseId?: string;
        }>, rawData: EntryProps<T>, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EntryProps<T>>;
    };
    environment: EnvironmentPlainClientAPI;
    environmentAlias: EnvironmentAliasPlainClientAPI;
    environmentTemplate: {
        create(params: GetOrganizationParams, rawData: CreateEnvironmentTemplateProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EnvironmentTemplateProps>;
        delete(params: GetEnvironmentTemplateParams, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<void>;
        disconnect(params: EnvironmentTemplateParams, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<void>;
        get(params: GetOrganizationParams & {
            environmentTemplateId: string;
        } & {
            query?: {
                select?: string;
            };
            version?: number;
        }, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EnvironmentTemplateProps>;
        getMany(params: GetOrganizationParams & {
            query?: BasicCursorPaginationOptions & {
                forTemplatedSpaces?: boolean;
                select?: string;
            };
        }, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        install(params: EnvironmentTemplateParams, rawData: CreateEnvironmentTemplateInstallationProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EnvironmentTemplateInstallationProps>;
        update(params: GetEnvironmentTemplateParams, rawData: EnvironmentTemplateProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EnvironmentTemplateProps>;
        validate(params: EnvironmentTemplateParams & {
            version?: number;
        }, rawData: ValidateEnvironmentTemplateInstallationProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EnvironmentTemplateValidationProps>;
        versions(params: GetOrganizationParams & {
            environmentTemplateId: string;
        } & {
            query?: BasicCursorPaginationOptions & {
                installable?: boolean;
                select?: string;
            };
        }, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        versionUpdate(params: GetOrganizationParams & {
            environmentTemplateId: string;
        } & {
            version: number;
        }, rawData: {
            versionDescription?: string;
            versionName?: string;
        }, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<EnvironmentTemplateProps>;
    };
    environmentTemplateInstallation: {
        getForEnvironment(params: BasicCursorPaginationOptions & EnvironmentTemplateParams & {
            installationId?: string;
        }, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>>;
        getMany(params: BasicCursorPaginationOptions & {
            environmentId?: string;
            environmentTemplateId: string;
            latestOnly?: boolean;
            organizationId: string;
            spaceId?: string;
        }, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>>;
    };
    experience: ExperiencePlainClientAPI;
    experienceFragment: ExperienceFragmentPlainClientAPI;
    experienceFragmentVariant: ExperienceFragmentVariantPlainClientAPI;
    experienceTemplate: ExperienceTemplatePlainClientAPI;
    experienceVariant: ExperienceVariantPlainClientAPI;
    extension: ExtensionPlainClientAPI;
    fragment: FragmentPlainClientAPI;
    function: FunctionPlainClientAPI;
    functionLog: FunctionLogPlainClientAPI;
    locale: LocalePlainClientAPI;
    oauthApplication: OAuthApplicationPlainClientAPI;
    organization: OrganizationPlainClientAPI;
    organizationInvitation: {
        create(params: OptionalDefaults<{
            organizationId: string;
        }>, data: CreateOrganizationInvitationProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<OrganizationInvitationProps>;
        get(params: OptionalDefaults<{
            invitationId: string;
            organizationId: string;
        }>, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<OrganizationInvitationProps>;
    };
    organizationMembership: {
        delete(params: OptionalDefaults<GetOrganizationMembershipParams>): Promise<any>;
        get(params: OptionalDefaults<GetOrganizationMembershipParams>): Promise<OrganizationMembershipProps>;
        getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<OrganizationMembershipProps>>;
        update(params: OptionalDefaults<GetOrganizationMembershipParams>, rawData: OrganizationMembershipProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<OrganizationMembershipProps>;
    };
    personalAccessToken: {
        create(rawData: CreatePersonalAccessTokenProps, headers?: Partial<RawAxiosHeaders & {
            Accept: AxiosHeaderValue;
            Authorization: AxiosHeaderValue;
            Content-Encoding: AxiosHeaderValue;
            Content-Length: AxiosHeaderValue;
            Location: AxiosHeaderValue;
            User-Agent: AxiosHeaderValue;
        } & {
            Content-Type: ContentType;
        }>): Promise<PersonalAccessTokenProps>;
        get(params: OptionalDefaults<{
            tokenId: string;
        }>): Promise<PersonalAccessTokenProps>;
        getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<PersonalAccessTokenProps>>;
        revoke(params: OptionalDefaults<{
            tokenId: string;
        }>): Promise<PersonalAccessTokenProps>;
    };
    previewApiKey: {
        get(params: OptionalDefaults<GetSpaceParams & {
            previewApiKeyId: string;
        }>): Promise<PreviewApiKeyProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<PreviewApiKeyProps>>;
    };
    raw: {
        delete<T>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
        get<T>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
        getDefaultParams(): undefined | PlainClientDefaultParams;
        http<T>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
        patch<T>(url: string, payload?: any, config?: RawAxiosRequestConfig): Promise<T>;
        post<T>(url: string, payload?: any, config?: RawAxiosRequestConfig): Promise<T>;
        put<T>(url: string, payload?: any, config?: RawAxiosRequestConfig): Promise<T>;
    };
    release: {
        asset: {
            create(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                releaseId: string;
            } & QueryParams>, rawData: CreateAssetProps, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
            createFromFiles(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                releaseId: string;
                uploadTimeout?: number;
            } & QueryParams>, data: Omit<AssetFileProp, "sys">, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
            createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                assetId: string;
                releaseId: string;
            } & QueryParams>, rawData: CreateAssetProps, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
            get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                assetId: string;
                releaseId: string;
            } & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
            getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                releaseId: string;
            } & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<CollectionProp<AssetProps<{
                release: Link<"Release">;
            }>>>;
            processForAllLocales(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps<{
                release: Link<"Release">;
            }>, processingOptions?: AssetProcessingForLocale): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
            processForLocale(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps<{
                release: Link<"Release">;
            }>, locale: string, processingOptions?: AssetProcessingForLocale): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
            update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                assetId: string;
                releaseId: string;
            } & QueryParams>, rawData: AssetProps, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<AssetProps<{
                release: Link<"Release">;
            }>>;
        };
        entry: {
            create<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                contentTypeId: string;
                releaseId: string;
            } & QueryParams>, rawData: CreateEntryProps<T>, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<EntryProps<T, {
                release: Link<"Release">;
            }>>;
            createWithId<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                contentTypeId: string;
                entryId: string;
                releaseId: string;
            } & QueryParams>, rawData: CreateEntryProps<T>, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<EntryProps<T, {
                release: Link<"Release">;
            }>>;
            get<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                entryId: string;
                releaseId: string;
            } & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<EntryProps<T, {
                release: Link<"Release">;
            }>>;
            getMany<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                releaseId: string;
            } & QueryParams>, rawData?: unknown, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<CollectionProp<EntryProps<T, {
                release: Link<"Release">;
            }>>>;
            patch<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                entryId: string;
                releaseId: string;
                version: number;
            } & QueryParams>, rawData: OpPatch[], headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<EntryProps<T, {
                release: Link<"Release">;
            }>>;
            update<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
                entryId: string;
                releaseId: string;
            } & QueryParams>, rawData: EntryProps<T>, headers?: Partial<RawAxiosHeaders & {
                Accept: AxiosHeaderValue;
                Authorization: AxiosHeaderValue;
                Content-Encoding: AxiosHeaderValue;
                Content-Length: AxiosHeaderValue;
                Location: AxiosHeaderValue;
                User-Agent: AxiosHeaderValue;
            } & {
                Content-Type: ContentType;
            }>): Promise<EntryProps<T, {
                release: Link<"Release">;
            }>>;
        };
        archive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseSchemaVersion?: "Release.v1" | "Release.v2";
        } & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseProps>;
        create(params: OptionalDefaults<ReleaseEnvironmentParams>, data: ReleasePayload | ReleasePayloadV2): Promise<ReleaseProps>;
        delete(params: OptionalDefaults<GetReleaseParams>): Promise<void>;
        get(params: OptionalDefaults<GetReleaseParams>): Promise<ReleaseProps>;
        publish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseSchemaVersion?: "Release.v1" | "Release.v2";
        } & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseActionProps<"publish">>;
        query(params: Omit<ReleaseEnvironmentParams, keyof PlainClientDefaultParams> & Partial<Pick<ReleaseEnvironmentParams, "releaseSchemaVersion" | (keyof GetSpaceEnvironmentParams)>> & {
            query?: ReleaseQueryOptions;
        }): Promise<CursorPaginatedCollectionProp<ReleaseProps>>;
        unarchive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseSchemaVersion?: "Release.v1" | "Release.v2";
        } & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseProps>;
        unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseSchemaVersion?: "Release.v1" | "Release.v2";
        } & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseActionProps<"unpublish">>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseSchemaVersion?: "Release.v1" | "Release.v2";
        } & {
            releaseId: string;
        } & {
            version: number;
        }>, data: ReleasePayload | ReleasePayloadV2): Promise<ReleaseProps>;
        validate(params: OptionalDefaults<GetReleaseParams>, data?: ReleaseValidatePayload): Promise<ReleaseActionProps<"validate">>;
    };
    releaseAction: {
        get(params: Omit<GetReleaseParams, keyof PlainClientDefaultParams> & Partial<Pick<GetReleaseParams, "releaseId" | "releaseSchemaVersion" | (keyof GetSpaceEnvironmentParams)>> & {
            actionId: string;
        }): Promise<ReleaseActionProps<any>>;
        getMany(params: Omit<GetSpaceEnvironmentParams, keyof PlainClientDefaultParams> & Partial<Pick<GetSpaceEnvironmentParams, keyof GetSpaceEnvironmentParams>> & {
            query?: ReleaseActionQueryOptions;
        }): Promise<CollectionProp<ReleaseActionProps<any>>>;
        queryForRelease(params: Omit<GetReleaseParams, keyof PlainClientDefaultParams> & Partial<Pick<GetReleaseParams, "releaseId" | "releaseSchemaVersion" | (keyof GetSpaceEnvironmentParams)>> & {
            query?: ReleaseActionQueryOptions;
        }): Promise<CollectionProp<ReleaseActionProps<any>>>;
    };
    resource: ResourcePlainAPI;
    resourceProvider: ResourceProviderPlainClientAPI;
    resourceType: ResourceTypePlainClientAPI;
    role: RolePlainClientAPI;
    scheduledActions: {
        create(params: OptionalDefaults<GetSpaceParams>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            scheduledActionId: string;
        }>): Promise<ScheduledActionProps>;
        get(params: Omit<GetSpaceParams, keyof PlainClientDefaultParams> & Partial<Pick<GetSpaceParams, "spaceId">> & {
            environmentId: string;
            scheduledActionId: string;
        }): Promise<ScheduledActionProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CursorPaginatedCollectionProp<ScheduledActionProps>>;
        update(params: OptionalDefaults<GetSpaceParams & {
            scheduledActionId: string;
            version: number;
        }>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>;
    };
    semanticDuplicates: SemanticDuplicatesPlainClientAPI;
    semanticRecommendations: SemanticRecommendationsPlainClientAPI;
    semanticReferenceSuggestions: SemanticReferenceSuggestionsPlainClientAPI;
    semanticSearch: SemanticSearchPlainClientAPI;
    semanticSettings: SemanticSettingsPlainClientAPI;
    snapshot: {
        getForContentType(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
        } & {
            snapshotId: string;
        }>): Promise<SnapshotProps<ContentTypeProps>>;
        getForEntry<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        } & {
            snapshotId: string;
        }>): Promise<SnapshotProps<Omit<EntryProps<T>, "metadata">>>;
        getManyForContentType(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
        } & QueryParams>): Promise<CollectionProp<SnapshotProps<ContentTypeProps>>>;
        getManyForEntry<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        } & QueryParams>): Promise<CollectionProp<SnapshotProps<Omit<EntryProps<T>, "metadata">>>>;
    };
    space: SpacePlainClientAPI;
    spaceMember: SpaceMemberPlainClientAPI;
    spaceMembership: SpaceMembershipPlainClientAPI;
    tag: TagPlainClientAPI;
    task: TaskPlainClientAPI;
    team: TeamPlainClientAPI;
    teamMembership: TeamMembershipPlainClientAPI;
    teamSpaceMembership: TeamSpaceMembershipPlainClientAPI;
    template: TemplatePlainClientAPI;
    uiConfig: UIConfigPlainClientAPI;
    upload: UploadPlainClientAPI;
    uploadCredential: UploadCredentialAPI;
    usage: UsagePlainClientAPI;
    user: UserPlainClientAPI;
    userUIConfig: UserUIConfigPlainClientAPI;
    webhook: WebhookPlainClientAPI;
    workflow: WorkflowPlainClientAPI;
    workflowDefinition: WorkflowDefinitionPlainClientAPI;
    workflowsChangelog: WorkflowsChangelogPlainClientAPI;
}

Type declaration

Settings

Member Visibility