Type alias PlainClientAPI

PlainClientAPI: {
    apiKey: {
        create(params: OptionalDefaults<GetSpaceParams>, data: CreateApiKeyProps, headers?: AxiosRequestHeaders): Promise<ApiKeyProps>;
        createWithId(params: OptionalDefaults<GetSpaceParams & {
            apiKeyId: string;
        }>, data: CreateApiKeyProps, headers?: AxiosRequestHeaders): 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?: AxiosRequestHeaders): Promise<ApiKeyProps>;
    };
    appAction: {
        create(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppActionProps): Promise<AppActionProps>;
        delete(params: OptionalDefaults<GetAppActionParams>): Promise<void>;
        get(params: OptionalDefaults<GetAppActionParams>): Promise<AppActionProps>;
        getMany(params: OptionalDefaults<GetOrganizationParams & {
            appDefinitionId: string;
        } & QueryParams>): Promise<CollectionProp<AppActionProps>>;
        getManyForEnvironment(params: OptionalDefaults<GetSpaceParams & {
            environmentId?: string;
        } & QueryParams>): Promise<CollectionProp<AppActionProps>>;
        update(params: OptionalDefaults<GetAppActionParams>, payload: CreateAppActionProps): Promise<AppActionProps>;
    };
    appActionCall: {
        create(params: OptionalDefaults<GetAppActionCallParams>, payload: CreateAppActionCallProps): Promise<AppActionCallProps>;
        getCallDetails(params: OptionalDefaults<GetAppActionCallDetailsParams>): Promise<WebhookCallDetailsProps>;
    };
    appBundle: {
        create(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppBundleProps): Promise<AppBundleProps>;
        delete(params: OptionalDefaults<GetAppBundleParams>): Promise<void>;
        get(params: OptionalDefaults<GetAppBundleParams>): Promise<AppBundleProps>;
        getMany(params: OptionalDefaults<GetOrganizationParams & {
            appDefinitionId: string;
        } & QueryParams>): Promise<CollectionProp<AppBundleProps>>;
    };
    appDefinition: {
        create(params: OptionalDefaults<GetOrganizationParams>, rawData: {
            locations: undefined | AppLocation[];
            name: string;
            parameters: undefined | {
                instance?: ParameterDefinition[];
            };
            src: undefined | string;
        }): Promise<AppDefinitionProps>;
        delete(params: OptionalDefaults<GetAppDefinitionParams>): Promise<any>;
        get(params: OptionalDefaults<GetOrganizationParams & {
            appDefinitionId: string;
        } & QueryParams>): Promise<AppDefinitionProps>;
        getInstallationsForOrg(params: OptionalDefaults<GetAppDefinitionParams>): Promise<AppInstallationsForOrganizationProps>;
        getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<AppDefinitionProps>>;
        update(params: OptionalDefaults<GetAppDefinitionParams>, rawData: AppDefinitionProps, headers?: AxiosRequestHeaders): Promise<AppDefinitionProps>;
    };
    appDetails: {
        delete(params: OptionalDefaults<GetAppDefinitionParams>): Promise<void>;
        get(params: OptionalDefaults<GetAppDefinitionParams>): Promise<AppDetailsProps>;
        upsert(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppDetailsProps): Promise<AppDetailsProps>;
    };
    appInstallation: {
        delete(params: OptionalDefaults<GetAppInstallationParams>): Promise<any>;
        get(params: OptionalDefaults<GetAppInstallationParams>): Promise<AppInstallationProps>;
        getForOrganization(params: OptionalDefaults<GetAppDefinitionParams>): Promise<AppInstallationsForOrganizationProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & PaginationQueryParams>): Promise<CollectionProp<AppInstallationProps>>;
        upsert(params: OptionalDefaults<GetAppInstallationParams>, rawData: Except<AppInstallationProps, "sys">, headers?: AxiosRequestHeaders): Promise<AppInstallationProps>;
    };
    appSignedRequest: {
        create(params: OptionalDefaults<GetAppInstallationParams>, payload: CreateAppSignedRequestProps): Promise<AppSignedRequestProps>;
    };
    appSigningSecret: {
        delete(params: OptionalDefaults<GetAppDefinitionParams>): Promise<void>;
        get(params: OptionalDefaults<GetAppDefinitionParams>): Promise<AppSigningSecretProps>;
        upsert(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppSigningSecretProps): Promise<AppSigningSecretProps>;
    };
    appUpload: {
        create(params: OptionalDefaults<GetOrganizationParams>, payload: {
            file: string | ArrayBuffer | Stream;
        }): Promise<AppUploadProps>;
        delete(params: OptionalDefaults<GetAppUploadParams>): Promise<void>;
        get(params: OptionalDefaults<GetAppUploadParams>): Promise<AppUploadProps>;
    };
    asset: {
        archive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<AssetProps>;
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateAssetProps): Promise<AssetProps>;
        createFromFiles(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: Omit<AssetFileProp, "sys">): Promise<AssetProps>;
        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>, rawData: CreateAssetProps): Promise<AssetProps>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        } & QueryParams>, rawData?: unknown, headers?: AxiosRequestHeaders): Promise<AssetProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: AxiosRequestHeaders): Promise<CollectionProp<AssetProps>>;
        processForAllLocales(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>;
        processForLocale(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps, locale: string, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>;
        publish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>, rawData: AssetProps): Promise<AssetProps>;
        unarchive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<AssetProps>;
        unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>): Promise<AssetProps>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            assetId: string;
        }>, rawData: AssetProps, headers?: AxiosRequestHeaders): Promise<AssetProps>;
    };
    assetKey: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateAssetKeyProps): Promise<AssetKeyProps>;
    };
    bulkAction: {
        get<T>(params: GetBulkActionParams): Promise<BulkActionProps<T>>;
        publish(params: GetSpaceEnvironmentParams, payload: BulkActionPublishPayload): Promise<BulkActionProps<BulkActionPublishPayload>>;
        unpublish(params: GetSpaceEnvironmentParams, payload: BulkActionUnpublishPayload): Promise<BulkActionProps<BulkActionUnpublishPayload>>;
        validate(params: GetSpaceEnvironmentParams, payload: BulkActionValidatePayload): Promise<BulkActionProps<BulkActionValidatePayload>>;
    };
    comment: {
        create(params: OptionalDefaults<CreateCommentParams>, rawData: CreateCommentProps, headers?: AxiosRequestHeaders): Promise<CommentProps>;
        delete(params: OptionalDefaults<DeleteCommentParams>): Promise<void>;
        get(params: OptionalDefaults<GetCommentParams>): Promise<CommentProps>;
        getMany(params: OptionalDefaults<Object>): Promise<CollectionProp<CommentProps>>;
        update(params: OptionalDefaults<GetCommentParams>, rawData: UpdateCommentProps, headers?: AxiosRequestHeaders): Promise<CommentProps>;
    };
    contentType: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: {
            description: undefined | string;
            displayField: undefined | string;
            fields: ContentFields<KeyValueMap>[];
            metadata: undefined | ContentTypeMetadata;
            name: string;
        }): Promise<ContentTypeProps>;
        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
        }>, rawData: {
            description: undefined | string;
            displayField: undefined | string;
            fields: ContentFields<KeyValueMap>[];
            metadata: undefined | 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>>;
        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?: AxiosRequestHeaders): Promise<ContentTypeProps>;
    };
    editorInterface: {
        get(params: OptionalDefaults<GetEditorInterfaceParams>): Promise<EditorInterfaceProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<EditorInterfaceProps>>;
        update(params: OptionalDefaults<GetEditorInterfaceParams>, rawData: EditorInterfaceProps, headers?: AxiosRequestHeaders): Promise<EditorInterfaceProps>;
    };
    entry: {
        archive<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>): Promise<EntryProps<T>>;
        create<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
        }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>;
        createWithId<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            contentTypeId: string;
            entryId: string;
        }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>): Promise<any>;
        get<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>, rawData?: unknown, headers?: AxiosRequestHeaders): Promise<EntryProps<T>>;
        getMany<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: AxiosRequestHeaders): Promise<CollectionProp<EntryProps<T>>>;
        getPublished<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: AxiosRequestHeaders): Promise<CollectionProp<EntryProps<T>>>;
        patch<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>, rawData: OpPatch[], headers?: AxiosRequestHeaders): Promise<EntryProps<T>>;
        publish<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: 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;
        }>): Promise<EntryProps<T>>;
        update<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        }>, rawData: EntryProps<T>, headers?: AxiosRequestHeaders): Promise<EntryProps<T>>;
    };
    environment: {
        create(params: OptionalDefaults<GetSpaceParams>, rawData: Partial<Pick<EnvironmentProps, "name">>, headers?: AxiosRequestHeaders): Promise<EnvironmentProps>;
        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            sourceEnvironmentId?: string;
        }>, rawData: Partial<Omit<EnvironmentProps, "sys">>, headers?: AxiosRequestHeaders): Promise<EnvironmentProps>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<EnvironmentProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>): Promise<CollectionProp<EnvironmentProps>>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: EnvironmentProps, headers?: AxiosRequestHeaders): Promise<EnvironmentProps>;
    };
    environmentAlias: {
        createWithId(params: OptionalDefaults<GetSpaceEnvAliasParams>, rawData: CreateEnvironmentAliasProps, headers?: AxiosRequestHeaders): Promise<EnvironmentAliasProps>;
        delete(params: OptionalDefaults<GetSpaceEnvAliasParams>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvAliasParams>): Promise<EnvironmentAliasProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>): Promise<CollectionProp<EnvironmentAliasProps>>;
        update(params: OptionalDefaults<GetSpaceEnvAliasParams>, rawData: EnvironmentAliasProps, headers?: AxiosRequestHeaders): Promise<EnvironmentAliasProps>;
    };
    environmentTemplate: {
        create(params: GetOrganizationParams, rawData: CreateEnvironmentTemplateProps, headers?: AxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
        delete(params: GetEnvironmentTemplateParams, headers?: AxiosRequestHeaders): Promise<void>;
        disconnect(params: EnvironmentTemplateParams, headers?: AxiosRequestHeaders): Promise<void>;
        get(params: GetOrganizationParams & {
            environmentTemplateId: string;
        } & {
            version?: number;
        }, headers?: AxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
        getMany(params: BasicCursorPaginationOptions & GetOrganizationParams, headers?: AxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        install(params: EnvironmentTemplateParams, rawData: CreateEnvironmentTemplateInstallationProps, headers?: AxiosRequestHeaders): Promise<EnvironmentTemplateInstallationProps>;
        update(params: GetEnvironmentTemplateParams, rawData: EnvironmentTemplateProps, headers?: AxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
        validate(params: EnvironmentTemplateParams & {
            version?: number;
        }, rawData: ValidateEnvironmentTemplateInstallationProps, headers?: AxiosRequestHeaders): Promise<EnvironmentTemplateValidationProps<ValidationFinding>>;
        versionUpdate(params: GetOrganizationParams & {
            environmentTemplateId: string;
        } & {
            version: number;
        }, rawData: {
            versionDescription?: string;
            versionName?: string;
        }, headers?: AxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
        versions(params: GetOrganizationParams & {
            environmentTemplateId: string;
        } & BasicCursorPaginationOptions, headers?: AxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
    };
    environmentTemplateInstallation: {
        getForEnvironment(params: BasicCursorPaginationOptions & EnvironmentTemplateParams & {
            installationId?: string;
        }, headers?: AxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>>;
        getMany(params: BasicCursorPaginationOptions & {
            environmentId?: string;
            environmentTemplateId: string;
            organizationId: string;
            spaceId?: string;
        }, headers?: AxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>>;
    };
    extension: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateUIExtensionProps, headers?: AxiosRequestHeaders): Promise<UIExtensionProps>;
        createWithId(params: OptionalDefaults<GetExtensionParams>, rawData: CreateUIExtensionProps, headers?: AxiosRequestHeaders): Promise<UIExtensionProps>;
        delete(params: OptionalDefaults<GetExtensionParams>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            extensionId: string;
        } & QueryParams>): Promise<UIExtensionProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<UIExtensionProps>>;
        update(params: OptionalDefaults<GetExtensionParams>, rawData: UIExtensionProps, headers?: AxiosRequestHeaders): Promise<UIExtensionProps>;
    };
    locale: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateLocaleProps, headers?: AxiosRequestHeaders): Promise<LocaleProps>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            localeId: string;
        }>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            localeId: string;
        }>): Promise<LocaleProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<LocaleProps>>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            localeId: string;
        }>, rawData: LocaleProps, headers?: AxiosRequestHeaders): Promise<LocaleProps>;
    };
    organization: {
        get(params: OptionalDefaults<GetOrganizationParams>): Promise<OrganizationProp>;
        getAll(params?: OptionalDefaults<PaginationQueryParams>): Promise<CollectionProp<OrganizationProp>>;
    };
    organizationInvitation: {
        create(params: OptionalDefaults<{
            organizationId: string;
        }>, data: CreateOrganizationInvitationProps, headers?: AxiosRequestHeaders): Promise<OrganizationInvitationProps>;
        get(params: OptionalDefaults<{
            invitationId: string;
            organizationId: string;
        }>, headers?: AxiosRequestHeaders): 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?: AxiosRequestHeaders): Promise<OrganizationMembershipProps>;
    };
    personalAccessToken: {
        create(rawData: CreatePersonalAccessTokenProps, headers?: AxiosRequestHeaders): Promise<PersonalAccessTokenProp>;
        get(params: OptionalDefaults<{
            tokenId: string;
        }>): Promise<PersonalAccessTokenProp>;
        getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<PersonalAccessTokenProp>>;
        revoke(params: OptionalDefaults<{
            tokenId: string;
        }>): Promise<PersonalAccessTokenProp>;
    };
    previewApiKey: {
        get(params: OptionalDefaults<GetSpaceParams & {
            previewApiKeyId: string;
        }>): Promise<PreviewApiKeyProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<PreviewApiKeyProps>>;
    };
    raw: {
        delete<T>(url: string, config?: AxiosRequestConfig<any>): Promise<T>;
        get<T>(url: string, config?: AxiosRequestConfig<any>): Promise<T>;
        getDefaultParams(): undefined | DefaultParams;
        http<T>(url: string, config?: AxiosRequestConfig<any>): Promise<T>;
        patch<T>(url: string, payload?: any, config?: AxiosRequestConfig<any>): Promise<T>;
        post<T>(url: string, payload?: any, config?: AxiosRequestConfig<any>): Promise<T>;
        put<T>(url: string, payload?: any, config?: AxiosRequestConfig<any>): Promise<T>;
    };
    release: {
        archive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseProps>;
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: ReleasePayload): Promise<ReleaseProps>;
        delete(params: OptionalDefaults<GetReleaseParams>): Promise<void>;
        get(params: OptionalDefaults<GetReleaseParams>): Promise<ReleaseProps>;
        publish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseActionProps<"publish">>;
        query(params: Omit<GetSpaceEnvironmentParams, keyof DefaultParams> & Record<string, unknown> & {
            spaceId?: string;
        } & {
            environmentId?: string;
        } & {
            query?: ReleaseQueryOptions;
        }): Promise<CursorPaginatedCollectionProp<ReleaseProps>>;
        unarchive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseProps>;
        unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId: string;
        } & {
            version: number;
        }>): Promise<ReleaseActionProps<"unpublish">>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            releaseId: string;
        } & {
            version: number;
        }>, data: ReleasePayload): Promise<ReleaseProps>;
        validate(params: OptionalDefaults<GetReleaseParams>, data?: ReleaseValidatePayload): Promise<ReleaseActionProps<"validate">>;
    };
    releaseAction: {
        get(params: Omit<GetReleaseParams, keyof DefaultParams> & Record<string, unknown> & {
            spaceId?: string;
        } & {
            environmentId?: string;
        } & {
            actionId: string;
        }): Promise<ReleaseActionProps<any>>;
        getMany(params: Omit<GetSpaceEnvironmentParams, keyof DefaultParams> & Record<string, unknown> & {
            spaceId?: string;
        } & {
            environmentId?: string;
        } & {
            query?: ReleaseActionQueryOptions;
        }): Promise<CollectionProp<ReleaseActionProps<any>>>;
        queryForRelease(params: Omit<GetReleaseParams, keyof DefaultParams> & Record<string, unknown> & {
            spaceId?: string;
        } & {
            environmentId?: string;
        } & {
            query?: ReleaseActionQueryOptions;
        }): Promise<CollectionProp<ReleaseActionProps<any>>>;
    };
    role: {
        create(params: OptionalDefaults<GetSpaceParams>, data: CreateRoleProps, headers?: AxiosRequestHeaders): Promise<RoleProps>;
        createWithId(params: OptionalDefaults<GetSpaceParams & {
            roleId: string;
        }>, data: CreateRoleProps, headers?: AxiosRequestHeaders): Promise<RoleProps>;
        delete(params: OptionalDefaults<GetSpaceParams & {
            roleId: string;
        }>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceParams & {
            roleId: string;
        }>): Promise<RoleProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<RoleProps>>;
        update(params: OptionalDefaults<GetSpaceParams & {
            roleId: string;
        }>, rawData: RoleProps, headers?: AxiosRequestHeaders): Promise<RoleProps>;
    };
    scheduledActions: {
        create(params: OptionalDefaults<GetSpaceParams>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>;
        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            scheduledActionId: string;
        }>): Promise<ScheduledActionProps>;
        get(params: Omit<GetSpaceParams, keyof DefaultParams> & Record<string, unknown> & {
            spaceId?: string;
        } & {
            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>;
    };
    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: {
        create(params: OptionalDefaults<{
            organizationId?: string;
        }>, payload: Omit<SpaceProps, "sys">, headers?: AxiosRequestHeaders): Promise<any>;
        delete(params: OptionalDefaults<GetSpaceParams>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceParams>): Promise<SpaceProps>;
        getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<SpaceProps>>;
        update(params: OptionalDefaults<GetSpaceParams>, payload: SpaceProps, headers?: AxiosRequestHeaders): Promise<SpaceProps>;
    };
    spaceMember: {
        get(params: OptionalDefaults<GetSpaceParams & {
            spaceMemberId: string;
        }>): Promise<SpaceMemberProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<SpaceMemberProps>>;
    };
    spaceMembership: {
        create(params: OptionalDefaults<GetSpaceParams>, data: CreateSpaceMembershipProps, headers?: AxiosRequestHeaders): Promise<SpaceMembershipProps>;
        createWithId(params: OptionalDefaults<GetSpaceMembershipProps>, data: CreateSpaceMembershipProps, headers?: AxiosRequestHeaders): Promise<SpaceMembershipProps>;
        delete(params: OptionalDefaults<GetSpaceMembershipProps>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceMembershipProps>): Promise<SpaceMembershipProps>;
        getForOrganization(params: OptionalDefaults<GetOrganizationParams & {
            spaceMembershipId: string;
        }>): Promise<SpaceMembershipProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<SpaceMembershipProps>>;
        getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<SpaceMembershipProps>>;
        update(params: OptionalDefaults<GetSpaceMembershipProps>, rawData: SpaceMembershipProps, headers?: AxiosRequestHeaders): Promise<SpaceMembershipProps>;
    };
    tag: {
        createWithId(params: OptionalDefaults<GetTagParams>, rawData: CreateTagProps): Promise<TagProps>;
        delete(params: OptionalDefaults<GetTagParams>, version: number): Promise<any>;
        get(params: OptionalDefaults<GetTagParams>): Promise<TagProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<TagProps>>;
        update(params: OptionalDefaults<GetTagParams>, rawData: UpdateTagProps, headers?: AxiosRequestHeaders): Promise<TagProps>;
    };
    task: {
        create(params: OptionalDefaults<GetEntryParams>, rawData: CreateTaskProps, headers?: AxiosRequestHeaders): Promise<TaskProps>;
        delete(params: OptionalDefaults<DeleteTaskParams>): Promise<void>;
        get(params: OptionalDefaults<GetTaskParams>): Promise<TaskProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            entryId: string;
        } & QueryParams>): Promise<CollectionProp<TaskProps>>;
        update(params: OptionalDefaults<GetTaskParams>, rawData: UpdateTaskProps, headers?: AxiosRequestHeaders): Promise<TaskProps>;
    };
    team: {
        create(params: OptionalDefaults<GetOrganizationParams>, rawData: CreateTeamProps, headers?: AxiosRequestHeaders): Promise<any>;
        delete(params: OptionalDefaults<GetTeamParams>): Promise<any>;
        get(params: OptionalDefaults<GetTeamParams>): Promise<TeamProps>;
        getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<TeamProps>>;
        getManyForSpace(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<TeamProps>>;
        update(params: OptionalDefaults<GetTeamParams>, rawData: TeamProps, headers?: AxiosRequestHeaders): Promise<TeamProps>;
    };
    teamMembership: {
        create(params: OptionalDefaults<GetTeamParams>, rawData: CreateTeamMembershipProps, headers?: AxiosRequestHeaders): Promise<TeamMembershipProps>;
        delete(params: OptionalDefaults<GetTeamMembershipParams>): Promise<any>;
        get(params: OptionalDefaults<GetTeamMembershipParams>): Promise<TeamMembershipProps>;
        getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<TeamMembershipProps>>;
        getManyForTeam(params: OptionalDefaults<GetTeamParams & QueryParams>): Promise<CollectionProp<TeamMembershipProps>>;
        update(params: OptionalDefaults<GetTeamMembershipParams>, rawData: TeamMembershipProps, headers?: AxiosRequestHeaders): Promise<TeamMembershipProps>;
    };
    teamSpaceMembership: {
        create(params: OptionalDefaults<GetSpaceParams & {
            teamId: string;
        }>, rawData: CreateTeamSpaceMembershipProps, headers?: AxiosRequestHeaders): Promise<TeamSpaceMembershipProps>;
        delete(params: OptionalDefaults<GetTeamSpaceMembershipParams>): Promise<any>;
        get(params: OptionalDefaults<GetTeamSpaceMembershipParams>): Promise<TeamSpaceMembershipProps>;
        getForOrganization(params: OptionalDefaults<GetOrganizationParams & {
            teamSpaceMembershipId: string;
        }>): Promise<TeamSpaceMembershipProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<TeamSpaceMembershipProps>>;
        getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams & {
            teamId?: string;
        }>): Promise<CollectionProp<TeamSpaceMembershipProps>>;
        update(params: OptionalDefaults<GetTeamSpaceMembershipParams>, rawData: TeamSpaceMembershipProps, headers?: AxiosRequestHeaders): Promise<TeamSpaceMembershipProps>;
    };
    uiConfig: {
        get(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<UIConfigProps>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: UIConfigProps): Promise<UIConfigProps>;
    };
    upload: {
        create(params: OptionalDefaults<GetSpaceParams>, data: {
            file: string | ArrayBuffer | Stream;
        }): Promise<any>;
        delete(params: OptionalDefaults<GetSpaceParams & {
            uploadId: string;
        }>): Promise<any>;
        get(params: OptionalDefaults<GetSpaceParams & {
            uploadId: string;
        }>): Promise<any>;
    };
    usage: {
        getManyForOrganization(params: OptionalDefaults<{
            organizationId: string;
        } & QueryParams>): Promise<CollectionProp<UsageProps>>;
        getManyForSpace(params: OptionalDefaults<{
            organizationId: string;
        } & QueryParams>): Promise<CollectionProp<UsageProps>>;
    };
    user: {
        getCurrent<T>(params?: QueryParams): Promise<T>;
        getForOrganization(params: OptionalDefaults<GetOrganizationParams & {
            userId: string;
        }>): Promise<UserProps>;
        getForSpace(params: OptionalDefaults<GetSpaceParams & {
            userId: string;
        }>): Promise<UserProps>;
        getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<UserProps>>;
        getManyForSpace(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<UserProps>>;
    };
    userUIConfig: {
        get(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<UserUIConfigProps>;
        update(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: UserUIConfigProps): Promise<UserUIConfigProps>;
    };
    webhook: {
        create(params: OptionalDefaults<GetSpaceParams>, rawData: {
            active: undefined | boolean;
            filters: undefined | WebhookFilter[];
            headers: undefined | WebhookHeader[];
            httpBasicPassword: undefined | string;
            httpBasicUsername: undefined | string;
            name: string;
            topics: string[];
            transformation: undefined | WebhookTransformation;
            url: string;
        }, headers?: AxiosRequestHeaders): Promise<WebhookProps>;
        delete(params: OptionalDefaults<GetWebhookParams>): Promise<any>;
        get(params: OptionalDefaults<GetWebhookParams>): Promise<WebhookProps>;
        getCallDetails(params: OptionalDefaults<GetWebhookCallDetailsUrl>): Promise<WebhookCallDetailsProps>;
        getHealthStatus(params: OptionalDefaults<GetWebhookParams>): Promise<WebhookHealthProps>;
        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<WebhookProps>>;
        getManyCallDetails(params: OptionalDefaults<GetSpaceParams & {
            webhookDefinitionId: string;
        } & QueryParams>): Promise<CollectionProp<Except<WebhookCallDetailsProps, "request" | "response">>>;
        update(params: OptionalDefaults<GetWebhookParams>, rawData: {
            active: undefined | boolean;
            filters: undefined | WebhookFilter[];
            headers: undefined | WebhookHeader[];
            httpBasicPassword: undefined | string;
            httpBasicUsername: undefined | string;
            name: string;
            topics: string[];
            transformation: undefined | WebhookTransformation;
            url: string;
        }): Promise<WebhookProps>;
    };
    workflow: {
        complete(params: OptionalDefaults<DeleteWorkflowParams>, headers?: AxiosRequestHeaders): Promise<void>;
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateWorkflowProps, headers?: AxiosRequestHeaders): Promise<WorkflowProps>;
        delete(params: OptionalDefaults<DeleteWorkflowParams>, headers?: AxiosRequestHeaders): Promise<void>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            query?: WorkflowQueryOptions;
        }>, headers?: AxiosRequestHeaders): Promise<CollectionProp<WorkflowProps>>;
        update(params: OptionalDefaults<GetWorkflowParams>, rawData: UpdateWorkflowProps, headers?: AxiosRequestHeaders): Promise<WorkflowProps>;
    };
    workflowDefinition: {
        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateWorkflowDefinitionProps, headers?: AxiosRequestHeaders): Promise<WorkflowDefinitionProps>;
        delete(params: OptionalDefaults<DeleteWorkflowDefinitionParams>, headers?: AxiosRequestHeaders): Promise<any>;
        get(params: OptionalDefaults<GetWorkflowDefinitionParams>, headers?: AxiosRequestHeaders): Promise<WorkflowDefinitionProps>;
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            query?: WorkflowDefinitionQueryOptions;
        }>, headers?: AxiosRequestHeaders): Promise<CollectionProp<WorkflowDefinitionProps>>;
        update(params: OptionalDefaults<GetWorkflowDefinitionParams>, rawData: UpdateWorkflowDefinitionProps, headers?: AxiosRequestHeaders): Promise<WorkflowDefinitionProps>;
    };
    workflowsChangelog: {
        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
            query: WorkflowsChangelogQueryOptions;
        }>, headers?: AxiosRequestHeaders): Promise<CollectionProp<WorkflowsChangelogEntryProps>>;
    };
}

Type declaration

Settings

Member Visibility

Theme