liferay-headless-rest-client/dist/clients/headless-admin-taxonomy-v1.0/types.gen.d.ts

A collection of Headless Clients used in Liferay Portal

/**
 * A list of asset libraries (spaces) that this vocabulary is associated with.
 */
export type AssetLibrary = {
    /**
     * The asset library's site ID.
     */
    id?: number;
    /**
     * The asset library's name.
     */
    readonly name?: string;
    /**
     * The localized asset library's name.
     */
    readonly name_i18n?: {
        [key: string]: string;
    };
    readonly 'x-class-name'?: string;
};
/**
 * The vocabulary's creator.
 */
export type Creator = {
    /**
     * An additional name for the user. This can be used for a middle name.
     */
    readonly additionalName?: string;
    /**
     * The type of the content.
     */
    readonly contentType?: string;
    /**
     * The user's external reference code.
     */
    readonly externalReferenceCode?: string;
    /**
     * The user's surname (last name).
     */
    readonly familyName?: string;
    /**
     * The user's first name.
     */
    readonly givenName?: string;
    /**
     * The user's ID.
     */
    readonly id?: number;
    /**
     * A relative URL to the user's profile image.
     */
    readonly image?: string;
    /**
     * The user's full name.
     */
    readonly name?: string;
    /**
     * A relative URL to the user's profile.
     */
    readonly profileURL?: string;
    readonly 'x-class-name'?: string;
};
/**
 * Represents a keyword that describes content. Properties follow the [keywords](https://schema.org/keywords) specification.
 */
export type Keyword = {
    readonly actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    /**
     * A list of asset libraries that are associated with this keyword.
     */
    assetLibraries?: Array<AssetLibrary>;
    readonly assetLibraryKey?: string;
    creator?: Creator;
    /**
     * The keyword's creation date.
     */
    readonly dateCreated?: string;
    /**
     * The keyword's most recent modification date.
     */
    readonly dateModified?: string;
    /**
     * The keyword's external reference code
     */
    externalReferenceCode?: string;
    /**
     * The keyword's ID.
     */
    readonly id?: number;
    /**
     * The number of times this keyword has been used with other assets.
     */
    readonly keywordUsageCount?: number;
    /**
     * The keyword's name.
     */
    name: string;
    /**
     * The external reference code of the site to which this keyword is scoped.
     */
    readonly siteExternalReferenceCode?: string;
    /**
     * The ID of the site to which this keyword is scoped.
     */
    readonly siteId?: number;
    /**
     * A flag that indicates whether the user making the requests is subscribed to this keyword.
     */
    readonly subscribed?: boolean;
    readonly 'x-class-name'?: string;
};
export type Facet = {
    facetCriteria?: string;
    facetValues?: Array<FacetValue>;
};
export type FacetValue = {
    numberOfOccurrences?: number;
    term?: string;
};
export type PagePermission = {
    items?: Array<Permission>;
    lastPage?: number;
    totalCount?: number;
    actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    page?: number;
    facets?: Array<Facet>;
    pageSize?: number;
};
export type Permission = {
    actionIds?: Array<string>;
    roleExternalReferenceCode?: string;
    roleName?: string;
    roleType?: string;
};
export type PageKeyword = {
    items?: Array<Keyword>;
    lastPage?: number;
    totalCount?: number;
    actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    page?: number;
    facets?: Array<Facet>;
    pageSize?: number;
};
export type PageTaxonomyCategory = {
    items?: Array<TaxonomyCategory>;
    lastPage?: number;
    totalCount?: number;
    actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    page?: number;
    facets?: Array<Facet>;
    pageSize?: number;
};
/**
 * The category's parent category, if it exists.
 */
export type ParentTaxonomyCategory = {
    /**
     * The parent taxonomy category's external reference code.
     */
    externalReferenceCode?: string;
    id?: number;
    name?: string;
    name_i18n?: {
        [key: string]: string;
    };
    readonly 'x-class-name'?: string;
};
/**
 * The parent category's `TaxonomyVocabulary`, if such a parent category exists.
 */
export type ParentTaxonomyVocabulary = {
    /**
     * The parent category's `TaxonomyVocabulary` external reference code.
     */
    externalReferenceCode?: string;
    readonly id?: number;
    readonly name?: string;
    readonly name_i18n?: {
        [key: string]: string;
    };
    readonly 'x-class-name'?: string;
};
/**
 * Represents a category, which is a hierarchical classification that can be associated with particular asset types. Properties follow the [category](https://schema.org/category) specification.
 */
export type TaxonomyCategory = {
    readonly actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    readonly assetLibraryKey?: string;
    /**
     * A list of languages the category has a translation for.
     */
    readonly availableLanguages?: Array<string>;
    creator?: Creator;
    /**
     * The category's creation date.
     */
    readonly dateCreated?: string;
    /**
     * The category's most recent modification date.
     */
    readonly dateModified?: string;
    /**
     * The category's text description.
     */
    description?: string;
    description_i18n?: {
        [key: string]: string;
    };
    /**
     * The category's external reference code
     */
    externalReferenceCode?: string;
    /**
     * The category's ID.
     */
    readonly id?: string;
    /**
     * The category's name.
     */
    name: string;
    name_i18n?: {
        [key: string]: string;
    };
    /**
     * The number of times this category has been used in other assets.
     */
    readonly numberOfTaxonomyCategories?: number;
    parentTaxonomyCategory?: ParentTaxonomyCategory;
    parentTaxonomyVocabulary?: ParentTaxonomyVocabulary;
    permissions?: Array<Permission>;
    /**
     * The external reference code of the site to which this category is scoped.
     */
    readonly siteExternalReferenceCode?: string;
    /**
     * The ID of the site to which this category is scoped.
     */
    readonly siteId?: number;
    /**
     * The category's properties.
     */
    taxonomyCategoryProperties?: Array<TaxonomyCategoryProperty>;
    readonly taxonomyCategoryUsageCount?: number;
    /**
     * The `TaxonomyVocabulary` id, only if the category does not have a parent category.
     */
    taxonomyVocabularyId?: number;
    viewableBy?: 'Anyone' | 'Members' | 'Owner';
    readonly 'x-class-name'?: string;
};
/**
 * Key value pair to associate detailed information with a category.
 */
export type TaxonomyCategoryProperty = {
    /**
     * The taxonomy category's external reference code.
     */
    externalReferenceCode?: string;
    /**
     * The taxonomy category property's key.
     */
    key: string;
    /**
     * The taxonomy category property's value.
     */
    value?: string;
    readonly 'x-class-name'?: string;
};
/**
 * A list of asset types that can be associated with this vocabulary.
 */
export type AssetType = {
    /**
     * A flag that marks if this type is required.
     */
    required?: boolean;
    /**
     * The asset's subtype.
     */
    subtype?: string;
    /**
     * The asset's type (e.g., `BlogPosting`, `Document`, etc.).
     */
    type?: string;
    /**
     * The classNameId of the asset's type.
     */
    typeId?: number;
    readonly 'x-class-name'?: string;
};
export type PageTaxonomyVocabulary = {
    items?: Array<TaxonomyVocabulary>;
    lastPage?: number;
    totalCount?: number;
    actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    page?: number;
    facets?: Array<Facet>;
    pageSize?: number;
};
/**
 * Represents a vocabulary, which is a grouping of categories for a specific purpose (e.g., classification, sorting, etc.).
 */
export type TaxonomyVocabulary = {
    readonly actions?: {
        [key: string]: {
            [key: string]: string;
        };
    };
    /**
     * A list of asset libraries (spaces) that this vocabulary is associated with.
     */
    assetLibraries?: Array<AssetLibrary>;
    readonly assetLibraryKey?: string;
    /**
     * A list of asset types that can be associated with this vocabulary.
     */
    assetTypes?: Array<AssetType>;
    /**
     * A list of languages the vocabulary has a translation for.
     */
    readonly availableLanguages?: Array<string>;
    creator?: Creator;
    /**
     * The vocabulary's creation date.
     */
    readonly dateCreated?: string;
    /**
     * The vocabulary's most recent modification date.
     */
    readonly dateModified?: string;
    /**
     * The vocabulary's text description.
     */
    description?: string;
    description_i18n?: {
        [key: string]: string;
    };
    /**
     * The vocabulary's external reference code.
     */
    externalReferenceCode?: string;
    /**
     * The vocabulary's ID.
     */
    readonly id?: number;
    /**
     * Whether multiple categories can be associated with this vocabulary.
     */
    multiValued?: boolean;
    /**
     * The vocabulary's name.
     */
    name: string;
    name_i18n?: {
        [key: string]: string;
    };
    /**
     * The number of categories that directly depend on this vocabulary.
     */
    readonly numberOfTaxonomyCategories?: number;
    permissions?: Array<Permission>;
    /**
     * The external reference code of the site to which this vocabulary is scoped.
     */
    readonly siteExternalReferenceCode?: string;
    /**
     * The ID of the site to which this vocabulary is scoped.
     */
    readonly siteId?: number;
    viewableBy?: 'Anyone' | 'Members' | 'Owner';
    readonly 'x-class-name'?: string;
    /**
     * The vocabulary's visibility type.
     */
    visibilityType?: 'PUBLIC' | 'INTERNAL';
};
export type DeleteAssetLibraryKeywordByExternalReferenceCodeData = {
    body?: never;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteAssetLibraryKeywordByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetAssetLibraryKeywordByExternalReferenceCodeData = {
    body?: never;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/by-external-reference-code/{externalReferenceCode}';
};
export type GetAssetLibraryKeywordByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type GetAssetLibraryKeywordByExternalReferenceCodeResponse = GetAssetLibraryKeywordByExternalReferenceCodeResponses[keyof GetAssetLibraryKeywordByExternalReferenceCodeResponses];
export type PutAssetLibraryKeywordByExternalReferenceCodeData = {
    body?: Keyword;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/by-external-reference-code/{externalReferenceCode}';
};
export type PutAssetLibraryKeywordByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type PutAssetLibraryKeywordByExternalReferenceCodeResponse = PutAssetLibraryKeywordByExternalReferenceCodeResponses[keyof PutAssetLibraryKeywordByExternalReferenceCodeResponses];
export type DeleteKeywordData = {
    body?: never;
    path: {
        keywordId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/keywords/{keywordId}';
};
export type DeleteKeywordResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetKeywordData = {
    body?: never;
    path: {
        keywordId: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/{keywordId}';
};
export type GetKeywordResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type GetKeywordResponse = GetKeywordResponses[keyof GetKeywordResponses];
export type PutKeywordData = {
    body?: Keyword;
    path: {
        keywordId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/keywords/{keywordId}';
};
export type PutKeywordResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type PutKeywordResponse = PutKeywordResponses[keyof PutKeywordResponses];
export type DeleteKeywordBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/batch';
};
export type DeleteKeywordBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostKeywordBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/batch';
};
export type PostKeywordBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PutKeywordBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/batch';
};
export type PutKeywordBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type DeleteSiteKeywordByExternalReferenceCodeData = {
    body?: never;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteSiteKeywordByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetSiteKeywordByExternalReferenceCodeData = {
    body?: never;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/by-external-reference-code/{externalReferenceCode}';
};
export type GetSiteKeywordByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type GetSiteKeywordByExternalReferenceCodeResponse = GetSiteKeywordByExternalReferenceCodeResponses[keyof GetSiteKeywordByExternalReferenceCodeResponses];
export type PutSiteKeywordByExternalReferenceCodeData = {
    body?: Keyword;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/by-external-reference-code/{externalReferenceCode}';
};
export type PutSiteKeywordByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type PutSiteKeywordByExternalReferenceCodeResponse = PutSiteKeywordByExternalReferenceCodeResponses[keyof PutSiteKeywordByExternalReferenceCodeResponses];
export type GetAssetLibraryKeywordPermissionsPageData = {
    body?: never;
    path: {
        assetLibraryId: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
        roleNames?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/permissions';
};
export type GetAssetLibraryKeywordPermissionsPageResponses = {
    /**
     * default response
     */
    default: PagePermission;
};
export type GetAssetLibraryKeywordPermissionsPageResponse = GetAssetLibraryKeywordPermissionsPageResponses[keyof GetAssetLibraryKeywordPermissionsPageResponses];
export type PutAssetLibraryKeywordPermissionsPageData = {
    body?: Array<Permission>;
    path: {
        assetLibraryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/permissions';
};
export type PutAssetLibraryKeywordPermissionsPageResponses = {
    /**
     * default response
     */
    default: PagePermission;
};
export type PutAssetLibraryKeywordPermissionsPageResponse = PutAssetLibraryKeywordPermissionsPageResponses[keyof PutAssetLibraryKeywordPermissionsPageResponses];
export type GetAssetLibraryKeywordsPageData = {
    body?: never;
    path: {
        assetLibraryId: string;
    };
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords';
};
export type GetAssetLibraryKeywordsPageResponses = {
    /**
     * default response
     */
    default: PageKeyword;
};
export type GetAssetLibraryKeywordsPageResponse = GetAssetLibraryKeywordsPageResponses[keyof GetAssetLibraryKeywordsPageResponses];
export type PostAssetLibraryKeywordData = {
    body?: Keyword;
    path: {
        assetLibraryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords';
};
export type PostAssetLibraryKeywordResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type PostAssetLibraryKeywordResponse = PostAssetLibraryKeywordResponses[keyof PostAssetLibraryKeywordResponses];
export type GetKeywordsPageData = {
    body?: never;
    path?: never;
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords';
};
export type GetKeywordsPageResponses = {
    /**
     * default response
     */
    default: PageKeyword;
};
export type GetKeywordsPageResponse = GetKeywordsPageResponses[keyof GetKeywordsPageResponses];
export type PostKeywordData = {
    body?: Keyword;
    path?: never;
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/keywords';
};
export type PostKeywordResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type PostKeywordResponse = PostKeywordResponses[keyof PostKeywordResponses];
export type GetKeywordsRankedPageData = {
    body?: never;
    path?: never;
    query?: {
        fields?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        siteId?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/ranked';
};
export type GetKeywordsRankedPageResponses = {
    /**
     * default response
     */
    default: PageKeyword;
};
export type GetKeywordsRankedPageResponse = GetKeywordsRankedPageResponses[keyof GetKeywordsRankedPageResponses];
export type GetSiteKeywordPermissionsPageData = {
    body?: never;
    path: {
        siteId: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
        roleNames?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/permissions';
};
export type GetSiteKeywordPermissionsPageResponses = {
    /**
     * default response
     */
    default: PagePermission;
};
export type GetSiteKeywordPermissionsPageResponse = GetSiteKeywordPermissionsPageResponses[keyof GetSiteKeywordPermissionsPageResponses];
export type PutSiteKeywordPermissionsPageData = {
    body?: Array<Permission>;
    path: {
        siteId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/permissions';
};
export type PutSiteKeywordPermissionsPageResponses = {
    /**
     * default response
     */
    default: PagePermission;
};
export type PutSiteKeywordPermissionsPageResponse = PutSiteKeywordPermissionsPageResponses[keyof PutSiteKeywordPermissionsPageResponses];
export type GetSiteKeywordsPageData = {
    body?: never;
    path: {
        siteId: string;
    };
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords';
};
export type GetSiteKeywordsPageResponses = {
    /**
     * default response
     */
    default: PageKeyword;
};
export type GetSiteKeywordsPageResponse = GetSiteKeywordsPageResponses[keyof GetSiteKeywordsPageResponses];
export type PostSiteKeywordData = {
    body?: Keyword;
    path: {
        siteId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords';
};
export type PostSiteKeywordResponses = {
    /**
     * default response
     */
    default: Keyword;
};
export type PostSiteKeywordResponse = PostSiteKeywordResponses[keyof PostSiteKeywordResponses];
export type PostAssetLibraryKeywordBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path: {
        assetLibraryId: string;
    };
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/batch';
};
export type PostAssetLibraryKeywordBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostAssetLibraryKeywordsPageExportBatchData = {
    body?: never;
    path: {
        assetLibraryId: string;
    };
    query?: {
        filter?: string;
        search?: string;
        sort?: string;
        callbackURL?: string;
        contentType?: string;
        fieldNames?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/keywords/export-batch';
};
export type PostAssetLibraryKeywordsPageExportBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostKeywordsPageExportBatchData = {
    body?: never;
    path?: never;
    query?: {
        filter?: string;
        search?: string;
        sort?: string;
        callbackURL?: string;
        contentType?: string;
        fieldNames?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/export-batch';
};
export type PostKeywordsPageExportBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostSiteKeywordBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path: {
        siteId: string;
    };
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/batch';
};
export type PostSiteKeywordBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostSiteKeywordsPageExportBatchData = {
    body?: never;
    path: {
        siteId: string;
    };
    query?: {
        filter?: string;
        search?: string;
        sort?: string;
        callbackURL?: string;
        contentType?: string;
        fieldNames?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/keywords/export-batch';
};
export type PostSiteKeywordsPageExportBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PutKeywordMergeData = {
    body?: never;
    path: {
        toKeywordId: string;
    };
    query?: {
        fromKeywordIds?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/keywords/{toKeywordId}/merge';
};
export type PutKeywordMergeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PutKeywordSubscribeData = {
    body?: never;
    path: {
        keywordId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/keywords/{keywordId}/subscribe';
};
export type PutKeywordSubscribeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PutKeywordUnsubscribeData = {
    body?: never;
    path: {
        keywordId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/keywords/{keywordId}/unsubscribe';
};
export type PutKeywordUnsubscribeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type DeleteAssetLibraryTaxonomyCategoryByExternalReferenceCodeData = {
    body?: never;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetAssetLibraryTaxonomyCategoryByExternalReferenceCodeData = {
    body?: never;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type GetAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type GetAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponse = GetAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses[keyof GetAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses];
export type PutAssetLibraryTaxonomyCategoryByExternalReferenceCodeData = {
    body?: TaxonomyCategory;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type PutAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PutAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponse = PutAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses[keyof PutAssetLibraryTaxonomyCategoryByExternalReferenceCodeResponses];
export type DeleteSiteTaxonomyCategoryByExternalReferenceCodeData = {
    body?: never;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteSiteTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetSiteTaxonomyCategoryByExternalReferenceCodeData = {
    body?: never;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type GetSiteTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type GetSiteTaxonomyCategoryByExternalReferenceCodeResponse = GetSiteTaxonomyCategoryByExternalReferenceCodeResponses[keyof GetSiteTaxonomyCategoryByExternalReferenceCodeResponses];
export type PutSiteTaxonomyCategoryByExternalReferenceCodeData = {
    body?: TaxonomyCategory;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type PutSiteTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PutSiteTaxonomyCategoryByExternalReferenceCodeResponse = PutSiteTaxonomyCategoryByExternalReferenceCodeResponses[keyof PutSiteTaxonomyCategoryByExternalReferenceCodeResponses];
export type DeleteTaxonomyCategoryData = {
    body?: never;
    path: {
        taxonomyCategoryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{taxonomyCategoryId}';
};
export type DeleteTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetTaxonomyCategoryData = {
    body?: never;
    path: {
        taxonomyCategoryId: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{taxonomyCategoryId}';
};
export type GetTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type GetTaxonomyCategoryResponse = GetTaxonomyCategoryResponses[keyof GetTaxonomyCategoryResponses];
export type PatchTaxonomyCategoryData = {
    body?: TaxonomyCategory;
    path: {
        taxonomyCategoryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{taxonomyCategoryId}';
};
export type PatchTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PatchTaxonomyCategoryResponse = PatchTaxonomyCategoryResponses[keyof PatchTaxonomyCategoryResponses];
export type PutTaxonomyCategoryData = {
    body?: TaxonomyCategory;
    path: {
        taxonomyCategoryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{taxonomyCategoryId}';
};
export type PutTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PutTaxonomyCategoryResponse = PutTaxonomyCategoryResponses[keyof PutTaxonomyCategoryResponses];
export type DeleteTaxonomyCategoryBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/batch';
};
export type DeleteTaxonomyCategoryBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PutTaxonomyCategoryBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/batch';
};
export type PutTaxonomyCategoryBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type DeleteTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeData = {
    body?: never;
    path: {
        taxonomyVocabularyId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeData = {
    body?: never;
    path: {
        taxonomyVocabularyId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type GetTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type GetTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponse = GetTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses[keyof GetTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses];
export type PutTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeData = {
    body?: TaxonomyCategory;
    path: {
        taxonomyVocabularyId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories/by-external-reference-code/{externalReferenceCode}';
};
export type PutTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PutTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponse = PutTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses[keyof PutTaxonomyVocabularyTaxonomyCategoryByExternalReferenceCodeResponses];
export type GetAssetLibraryTaxonomyCategoriesPageData = {
    body?: never;
    path: {
        assetLibraryId: string;
    };
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories';
};
export type GetAssetLibraryTaxonomyCategoriesPageResponses = {
    /**
     * default response
     */
    default: PageTaxonomyCategory;
};
export type GetAssetLibraryTaxonomyCategoriesPageResponse = GetAssetLibraryTaxonomyCategoriesPageResponses[keyof GetAssetLibraryTaxonomyCategoriesPageResponses];
export type PostAssetLibraryTaxonomyCategoryData = {
    body?: TaxonomyCategory;
    path: {
        assetLibraryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories';
};
export type PostAssetLibraryTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PostAssetLibraryTaxonomyCategoryResponse = PostAssetLibraryTaxonomyCategoryResponses[keyof PostAssetLibraryTaxonomyCategoryResponses];
export type GetSiteTaxonomyCategoriesPageData = {
    body?: never;
    path: {
        siteId: string;
    };
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories';
};
export type GetSiteTaxonomyCategoriesPageResponses = {
    /**
     * default response
     */
    default: PageTaxonomyCategory;
};
export type GetSiteTaxonomyCategoriesPageResponse = GetSiteTaxonomyCategoriesPageResponses[keyof GetSiteTaxonomyCategoriesPageResponses];
export type PostSiteTaxonomyCategoryData = {
    body?: TaxonomyCategory;
    path: {
        siteId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories';
};
export type PostSiteTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PostSiteTaxonomyCategoryResponse = PostSiteTaxonomyCategoryResponses[keyof PostSiteTaxonomyCategoryResponses];
export type GetTaxonomyCategoriesRankedPageData = {
    body?: never;
    path?: never;
    query?: {
        fields?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        siteId?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/ranked';
};
export type GetTaxonomyCategoriesRankedPageResponses = {
    /**
     * default response
     */
    default: PageTaxonomyCategory;
};
export type GetTaxonomyCategoriesRankedPageResponse = GetTaxonomyCategoriesRankedPageResponses[keyof GetTaxonomyCategoriesRankedPageResponses];
export type GetTaxonomyCategoryPermissionsPageData = {
    body?: never;
    path: {
        taxonomyCategoryId: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
        roleNames?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{taxonomyCategoryId}/permissions';
};
export type GetTaxonomyCategoryPermissionsPageResponses = {
    /**
     * default response
     */
    default: PagePermission;
};
export type GetTaxonomyCategoryPermissionsPageResponse = GetTaxonomyCategoryPermissionsPageResponses[keyof GetTaxonomyCategoryPermissionsPageResponses];
export type PutTaxonomyCategoryPermissionsPageData = {
    body?: Array<Permission>;
    path: {
        taxonomyCategoryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{taxonomyCategoryId}/permissions';
};
export type PutTaxonomyCategoryPermissionsPageResponses = {
    /**
     * default response
     */
    default: PagePermission;
};
export type PutTaxonomyCategoryPermissionsPageResponse = PutTaxonomyCategoryPermissionsPageResponses[keyof PutTaxonomyCategoryPermissionsPageResponses];
export type GetTaxonomyCategoryTaxonomyCategoriesPageData = {
    body?: never;
    path: {
        parentTaxonomyCategoryId: string;
    };
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{parentTaxonomyCategoryId}/taxonomy-categories';
};
export type GetTaxonomyCategoryTaxonomyCategoriesPageResponses = {
    /**
     * default response
     */
    default: PageTaxonomyCategory;
};
export type GetTaxonomyCategoryTaxonomyCategoriesPageResponse = GetTaxonomyCategoryTaxonomyCategoriesPageResponses[keyof GetTaxonomyCategoryTaxonomyCategoriesPageResponses];
export type PostTaxonomyCategoryTaxonomyCategoryData = {
    body?: TaxonomyCategory;
    path: {
        parentTaxonomyCategoryId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-categories/{parentTaxonomyCategoryId}/taxonomy-categories';
};
export type PostTaxonomyCategoryTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PostTaxonomyCategoryTaxonomyCategoryResponse = PostTaxonomyCategoryTaxonomyCategoryResponses[keyof PostTaxonomyCategoryTaxonomyCategoryResponses];
export type GetTaxonomyVocabularyTaxonomyCategoriesPageData = {
    body?: never;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: {
        aggregationTerms?: string;
        fields?: string;
        filter?: string;
        flatten?: string;
        page?: string;
        pageSize?: string;
        restrictFields?: string;
        search?: string;
        sort?: string;
        nestedFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories';
};
export type GetTaxonomyVocabularyTaxonomyCategoriesPageResponses = {
    /**
     * default response
     */
    default: PageTaxonomyCategory;
};
export type GetTaxonomyVocabularyTaxonomyCategoriesPageResponse = GetTaxonomyVocabularyTaxonomyCategoriesPageResponses[keyof GetTaxonomyVocabularyTaxonomyCategoriesPageResponses];
export type PostTaxonomyVocabularyTaxonomyCategoryData = {
    body?: TaxonomyCategory;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories';
};
export type PostTaxonomyVocabularyTaxonomyCategoryResponses = {
    /**
     * default response
     */
    default: TaxonomyCategory;
};
export type PostTaxonomyVocabularyTaxonomyCategoryResponse = PostTaxonomyVocabularyTaxonomyCategoryResponses[keyof PostTaxonomyVocabularyTaxonomyCategoryResponses];
export type PostAssetLibraryTaxonomyCategoriesPageExportBatchData = {
    body?: never;
    path: {
        assetLibraryId: string;
    };
    query?: {
        filter?: string;
        search?: string;
        sort?: string;
        callbackURL?: string;
        contentType?: string;
        fieldNames?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories/export-batch';
};
export type PostAssetLibraryTaxonomyCategoriesPageExportBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostAssetLibraryTaxonomyCategoryBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path: {
        assetLibraryId: string;
    };
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-categories/batch';
};
export type PostAssetLibraryTaxonomyCategoryBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostSiteTaxonomyCategoriesPageExportBatchData = {
    body?: never;
    path: {
        siteId: string;
    };
    query?: {
        filter?: string;
        search?: string;
        sort?: string;
        callbackURL?: string;
        contentType?: string;
        fieldNames?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories/export-batch';
};
export type PostSiteTaxonomyCategoriesPageExportBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostSiteTaxonomyCategoryBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path: {
        siteId: string;
    };
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-categories/batch';
};
export type PostSiteTaxonomyCategoryBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostTaxonomyVocabularyTaxonomyCategoriesPageExportBatchData = {
    body?: never;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: {
        filter?: string;
        search?: string;
        sort?: string;
        callbackURL?: string;
        contentType?: string;
        fieldNames?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories/export-batch';
};
export type PostTaxonomyVocabularyTaxonomyCategoriesPageExportBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostTaxonomyVocabularyTaxonomyCategoryBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path: {
        taxonomyVocabularyId: string;
    };
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}/taxonomy-categories/batch';
};
export type PostTaxonomyVocabularyTaxonomyCategoryBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type DeleteAssetLibraryTaxonomyVocabularyByExternalReferenceCodeData = {
    body?: never;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-vocabularies/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetAssetLibraryTaxonomyVocabularyByExternalReferenceCodeData = {
    body?: never;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-vocabularies/by-external-reference-code/{externalReferenceCode}';
};
export type GetAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type GetAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponse = GetAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses[keyof GetAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses];
export type PutAssetLibraryTaxonomyVocabularyByExternalReferenceCodeData = {
    body?: TaxonomyVocabulary;
    path: {
        assetLibraryId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/asset-libraries/{assetLibraryId}/taxonomy-vocabularies/by-external-reference-code/{externalReferenceCode}';
};
export type PutAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type PutAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponse = PutAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses[keyof PutAssetLibraryTaxonomyVocabularyByExternalReferenceCodeResponses];
export type DeleteSiteTaxonomyVocabularyByExternalReferenceCodeData = {
    body?: never;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-vocabularies/by-external-reference-code/{externalReferenceCode}';
};
export type DeleteSiteTaxonomyVocabularyByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetSiteTaxonomyVocabularyByExternalReferenceCodeData = {
    body?: never;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-vocabularies/by-external-reference-code/{externalReferenceCode}';
};
export type GetSiteTaxonomyVocabularyByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type GetSiteTaxonomyVocabularyByExternalReferenceCodeResponse = GetSiteTaxonomyVocabularyByExternalReferenceCodeResponses[keyof GetSiteTaxonomyVocabularyByExternalReferenceCodeResponses];
export type PutSiteTaxonomyVocabularyByExternalReferenceCodeData = {
    body?: TaxonomyVocabulary;
    path: {
        siteId: string;
        externalReferenceCode: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/sites/{siteId}/taxonomy-vocabularies/by-external-reference-code/{externalReferenceCode}';
};
export type PutSiteTaxonomyVocabularyByExternalReferenceCodeResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type PutSiteTaxonomyVocabularyByExternalReferenceCodeResponse = PutSiteTaxonomyVocabularyByExternalReferenceCodeResponses[keyof PutSiteTaxonomyVocabularyByExternalReferenceCodeResponses];
export type DeleteTaxonomyVocabularyData = {
    body?: never;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}';
};
export type DeleteTaxonomyVocabularyResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type GetTaxonomyVocabularyData = {
    body?: never;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: {
        fields?: string;
        restrictFields?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}';
};
export type GetTaxonomyVocabularyResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type GetTaxonomyVocabularyResponse = GetTaxonomyVocabularyResponses[keyof GetTaxonomyVocabularyResponses];
export type PatchTaxonomyVocabularyData = {
    body?: TaxonomyVocabulary;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}';
};
export type PatchTaxonomyVocabularyResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type PatchTaxonomyVocabularyResponse = PatchTaxonomyVocabularyResponses[keyof PatchTaxonomyVocabularyResponses];
export type PutTaxonomyVocabularyData = {
    body?: TaxonomyVocabulary;
    path: {
        taxonomyVocabularyId: string;
    };
    query?: never;
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/{taxonomyVocabularyId}';
};
export type PutTaxonomyVocabularyResponses = {
    /**
     * default response
     */
    default: TaxonomyVocabulary;
};
export type PutTaxonomyVocabularyResponse = PutTaxonomyVocabularyResponses[keyof PutTaxonomyVocabularyResponses];
export type DeleteTaxonomyVocabularyBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?: string;
    };
    url: '/o/headless-admin-taxonomy/v1.0/taxonomy-vocabularies/batch';
};
export type DeleteTaxonomyVocabularyBatchResponses = {
    /**
     * default response
     */
    default: unknown;
};
export type PostTaxonomyVocabularyBatchData = {
    body?: {
        [key: string]: unknown;
    };
    path?: never;
    query?: {
        callbackURL?