import { ApiClient, ClientOptions, ExceptProject, ApiClientError } from '@uniformdev/context/api'; export { ApiClientError } from '@uniformdev/context/api'; import { AssetGetResponseSingle, AssetDefinitionType, AssetParamValue, AssetParamValueItem } from '@uniformdev/assets'; export { AssetParamValue, AssetParamValueItem } from '@uniformdev/assets'; import { EndpointOut, EndpointHeadersOut, EndpointTransformationOut } from 'svix'; import { Quirks, StorageCommands, PersonalizedVariant, VariationMatchMetadata, TestVariant } from '@uniformdev/context'; import { Options as Options$1 } from 'p-retry'; import { Options } from 'p-throttle'; import { LinkAttributesConfiguration, RichTextBuiltInElement as RichTextBuiltInElement$1, RichTextBuiltInFormat as RichTextBuiltInFormat$1, RichTextParamConfiguration as RichTextParamConfiguration$1, ParameterRichTextValue } from '@uniformdev/richtext'; interface paths$n { "/api/v1/categories": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { projectId: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { categories: components$r["schemas"]["Category"][]; }; }; }; 400: components$r["responses"]["BadRequestError"]; 401: components$r["responses"]["UnauthorizedError"]; 403: components$r["responses"]["ForbiddenError"]; 429: components$r["responses"]["RateLimitError"]; 500: components$r["responses"]["InternalServerError"]; }; }; put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** Format: uuid */ projectId: string; categories: components$r["schemas"]["Category"][]; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$r["responses"]["BadRequestError"]; 401: components$r["responses"]["UnauthorizedError"]; 403: components$r["responses"]["ForbiddenError"]; 429: components$r["responses"]["RateLimitError"]; 500: components$r["responses"]["InternalServerError"]; }; }; post?: never; delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** Format: uuid */ categoryId: string; /** Format: uuid */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$r["responses"]["BadRequestError"]; 401: components$r["responses"]["UnauthorizedError"]; 403: components$r["responses"]["ForbiddenError"]; 429: components$r["responses"]["RateLimitError"]; 500: components$r["responses"]["InternalServerError"]; }; }; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$r { schemas: { /** Category for tagging canvas entities */ Category: { /** * Format: uuid * Unique identifier for the category */ id: string; /** Display name of the category */ name: string; /** * Sets the order of the category when displayed in a list with other categories. If not set, the order defaults to alphabetical with any explicitly set orders first in the list * @defaultValue 0 */ order?: number; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$r["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$r["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$r["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } interface components$q { schemas: { /** Public ID (used in code). Do not change after creation */ PublicIdProperty: string; /** The definition of a component parameter */ ComponentDefinitionParameter: { id: components$q["schemas"]["PublicIdProperty"]; /** Friendly name of the parameter */ name: string; /** Appears next to the parameter in the Composition editor */ helpText?: string; /** Context provided to AI when generating content for this parameter. May also be shown to humans. */ guidance?: string; /** Type name of the parameter (provided by a Uniform integration) */ type: string; /** * If true, this property can have locale-specific values. If false or not defined, * this property will have a single value that is shared for all locales */ localizable?: boolean; /** * When `localizable` is true, this property controls the default localizability of the property. * true - when the property has no existing value, it will be in 'single value' mode and not store locale specific values * false/undefined - when the property has no existing value, it will store separate values for each enabled locale * * If `localized` is false, this has no effect. */ notLocalizedByDefault?: boolean; /** * Enables creating additional conditional values for the parameter based on criteria such as dynamic inputs. * When combined with a localized value, each locale has independent conditional values. * * When not defined, conditional values are not allowed. */ allowConditionalValues?: boolean; /** The configuration object for the type (type-specific) */ typeConfig?: unknown; }; /** The definition of a named component slot that can contain other components */ ComponentDefinitionSlot: { id: components$q["schemas"]["PublicIdProperty"]; /** Friendly name of the slot */ name: string; /** A list of component definition public IDs that are allowed in this named slot */ allowedComponents: string[]; /** * Whether this slot inherits its allowed components from the parent slot it lives in. If true, `allowedComponents` is irrelevant. * If `allowAllComponents` is true, this value is ignored * @defaultValue false */ inheritAllowedComponents: boolean; /** * When false or not defined, only components in `allowedComponents` may be added to this slot - and if `allowedComponents` is empty, nothing can be added. * When true, every component and pattern that is defined may be added to this slot regardless of any other setting including `inheritAllowedComponents` */ allowAllComponents?: boolean; /** * When not defined, or false: all patterns for components listed in `allowedComponents` are automatically allowed in the slot. * When true: patterns for components listed in `allowedComponents` are not allowed in the slot unless explicitly added to `allowedComponents` as `$p:` */ patternsInAllowedComponents?: boolean; /** Minimum valid number of components in this slot */ minComponents?: number; /** Maximum valid number of components in this slot */ maxComponents?: number; }; /** The definition of a composition's slug settings */ ComponentDefinitionSlugSettings: { /** * Whether the slug is required * no: slug is optional * yes: slug is required * disabled: slug is disabled and will not be shown in the editor * @defaultValue no */ required?: "no" | "yes" | "disabled"; /** * Slug uniqueness configuration. * no = no unique constraint * local = must be unique within this component type * global = must be unique across all component types */ unique?: "no" | "local" | "global"; /** Regular expression slugs must match */ regularExpression?: string; /** * Custom error message when regular expression validation fails. * Has no effect if `regularExpression` is not set */ regularExpressionMessage?: string; }; /** The definition of a component variant */ ComponentDefinitionVariant: { id: components$q["schemas"]["PublicIdProperty"]; /** Friendly name of the variant */ name: string; }; /** Permission set for a component definition */ ComponentDefinitionPermission: { roleId: components$q["schemas"]["PublicIdProperty"]; /** * Permission type for this permission ComponentDefinition: * read | write | create | delete */ permission: "read" | "write" | "create" | "delete"; /** State of the component that this permission applies to */ state: number; }; /** Defines a component type that can live on a Composition */ ComponentDefinition: { id: components$q["schemas"]["PublicIdProperty"]; /** Friendly name of the component definition */ name: string; /** * Icon name for the component definition (e.g. 'screen') * @defaultValue screen */ icon?: string; /** * The public ID of the parameter whose value should be used to create a display title for this component in the UI. * The parameter type must support being used as a title parameter for this to work * @defaultValue null */ titleParameter?: string | null; /** * The public ID of the parameter whose value should be used as a thumbnail for compositions of this component in the UI * @defaultValue null */ thumbnailParameter?: string | null; /** * Whether this component type can be the root of a composition. If false, this component is only used within slots on other components * @defaultValue false */ canBeComposition?: boolean; /** The parameters for this component. Parameters are key-value pairs that can be anything from text values to links to CMS entries */ parameters?: components$q["schemas"]["ComponentDefinitionParameter"][]; /** * Format: uuid * Reference to the category this component definition belongs to * @defaultValue null */ categoryId?: string | null; /** Description of the component definition */ description?: string; /** Preview image URL for the component definition (shown in the UI) */ previewImageUrl?: string; /** * if this component uses team permissions or custom permissions * @defaultValue true */ useTeamPermissions?: boolean; /** Custom role permissions for this component definition */ permissions?: components$q["schemas"]["ComponentDefinitionPermission"][]; /** The named slots for this component; placement areas where arrays of other components can be added */ slots?: components$q["schemas"]["ComponentDefinitionSlot"][]; slugSettings?: components$q["schemas"]["ComponentDefinitionSlugSettings"]; /** Default component instance value */ defaults?: components$q["schemas"]["ComponentInstance"] | null; /** Named variants for this component; enables the creation of visual variants that use the same parameter data */ variants?: components$q["schemas"]["ComponentDefinitionVariant"][]; /** Created date string for this definition (ignored for writes) */ created?: string; /** Last modified date string for this definition (ignored for writes) */ updated?: string; /** * Format: uuid * ID of the workflow that instances of this component definition will use by default. When not set, no workflow is attached */ workflowId?: string; }; /** Defines a content type */ ContentType: { id: components$q["schemas"]["PublicIdProperty"]; /** Friendly name of the content type */ name: string; /** * The public ID of the field whose value should be used to create a display name for entries of this content type in the UI. * The field type must support being used as an entry name for this to work */ entryName?: string | null; /** * The public ID of the field whose value should be used as a thumbnail for entries of this content type in the UI * @defaultValue null */ thumbnailField?: string | null; /** The fields for this content type. Fields are key-value pairs that can be text, numbers, JSON objects, etc. */ fields?: components$q["schemas"]["ComponentDefinitionParameter"][]; /** Description of the content type */ description?: string; /** * Icon name for the content type (e.g. 'screen') * @defaultValue file-document */ icon?: string; /** Created date string for this content type (ignored for writes) */ created?: string; /** Last modified date string for this content type (ignored for writes) */ updated?: string; slugSettings?: components$q["schemas"]["ComponentDefinitionSlugSettings"]; /** * The definition type of this content type (block or content type) * @defaultValue contentType */ type?: "contentType" | "block"; /** * if this content type uses team permissions or custom permissions * @defaultValue true */ useTeamPermissions?: boolean; /** Custom role permissions for this content type */ permissions?: components$q["schemas"]["ComponentDefinitionPermission"][]; /** * Format: uuid * ID of the workflow that instances of this content type will use by default. When not set, no workflow is attached */ workflowId?: string; /** Configurations for previewing an entry on a consuming pattern or composition. */ previewConfigurations?: components$q["schemas"]["ContentTypePreviewConfiguration"][]; }; /** Defines a configuration for previewing an entry on a consuming pattern or composition. */ ContentTypePreviewConfiguration: { /** * The type of preview configuration */ type: "pattern" | "project-map"; /** Display label for the preview configuration */ label: string; /** * Format: uuid * Target preview entity ID (project map node ID or pattern ID) */ id: string; /** Optional mapping of dynamic input names to their values */ dynamicInputs?: { [key: string]: string; }; }; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$q["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$q["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$q["schemas"]["ComponentParameterConditions"]; }; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$q["schemas"]["ComponentParameterConditionalValue"][]; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$q["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$q["schemas"]["VisibilityCriteria"] | components$q["schemas"]["VisibilityCriteriaGroup"])[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$q["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$q["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$q["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$q["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$q["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$q["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$q["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$q["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** Defines the shape of the root component in a composition */ RootComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$q["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Project map nodes associated with this component. Must pass withProjectMapNodes parameter to be populated */ projectMapNodes?: components$q["schemas"]["CompositionProjectMapNodeInfo"][]; /** Slots containing any child components */ slots?: { [key: string]: components$q["schemas"]["ComponentInstance"][]; }; /** The ID of the composition */ _id: string; /** Slug pattern of this component */ _slug?: string | null; /** Friendly name of this component */ _name: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$q["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _dataResources?: components$q["schemas"]["DataResourceDefinitions"]; _patternError?: components$q["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$q["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$q["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$q["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the composition. If empty, the current default locale implicitly has data */ _locales?: string[]; /** * Names of opt-in global query strings surfaced in the Canvas editor for this composition or pattern. * Opt-ins coming from a resolved pattern move to _patternOptedInQueryStrings, so this always * holds only what was authored here. Omitted whenever overrides are resolved. */ _optedInQueryStrings?: string[]; }; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$q["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$q["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$q["schemas"]["DataResourceDefinition"]; }; }; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$q["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** Additional set of headers, parameters, variables, etc to be used for data resolving in the context like e.g. Unpublished Data. */ AlternativeDataSourceData: { /** Base resource URL of the data source. No trailing slash */ baseUrl: string; /** HTTP headers to pass with requests to the data source */ headers?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Variables needed to make calls to the data source */ variables?: { [key: string]: components$q["schemas"]["DataVariableDefinition"]; }; }; /** * An instance of a data source (i.e. "Master environment of the stable space", "Yelp API", "Sanity dev dataset"). * These are created in the UI and shared across a whole project. * NOTE: If you acquire a list of data sources or do not have manage permissions, you will receive "SECRET" * for all header, parameter, and variable values to obscure the actual encrypted secret value */ DataSource: { /** Public ID of the data source */ id: string; /** Display name of the data source */ displayName: string; /** The type of data connector this connects to (e.g. 'cms-items', provided by an installed integration) */ connectorType: string; /** Base resource URL of the data source. No trailing slash */ baseUrl: string; /** HTTP headers to pass with requests to the data source */ headers?: { key: string; value: string; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; }[]; /** Variables needed to make calls to the data source */ variables?: { [key: string]: components$q["schemas"]["DataVariableDefinition"]; }; /** * Mapping of locale codes to data source locale codes. Keys are Uniform locale codes, values are data source locale codes. * If a locale is not mapped, it will be passed through to the data source as-is */ localeMapping?: { [key: string]: string; }; /** * If true, data source will require additional credentials to access unpublished data. * If false, no additional data source credentials are required and data resources of this data source won't be able to access unpublished data. */ enableUnpublishedMode?: boolean; /** Custom configuration accessible to all data connector UIs (data source, data type, and data resource editors) and custom edgehancers. This data should not contain secrets */ customPublic?: { [key: string]: unknown; }; /** Custom configuration accessible to the data source editor UI and custom edgehancer that may contain secrets. This cannot be read by the data type or data resource editors */ custom?: { [key: string]: unknown; }; /** Different connector detail variants to use in the different contexts like e.g. Unpublished Data */ variants?: { unpublished?: components$q["schemas"]["AlternativeDataSourceData"]; }; /** Created date of the data source in ISO 8601 format (ignored for writes) */ created?: string; /** Last modified date of the data source in ISO 8601 format (ignored for writes) */ modified?: string; /** User or API key ID that created the data source (ignored for writes) */ createdBy?: string; /** User or API key ID that last modified the data source (ignored for writes) */ modifiedBy?: string; }; /** A specific type of data that a Data Source can provide (i.e. "Recipe", "Recipes List by Tag", "Yelp Reviews of My Restaurant"). These are created in the UI and shared a whole project */ DataType: { /** Public ID of the data type */ id: string; /** Display name of the data type */ displayName: string; /** Public ID of the associated data source */ dataSourceId: string; /** * A connector-specific archetype for this data type; used to select UI as well as perform any * necessary post-processing on the response. e.g. 'cms-entry', 'cms-query'. Can be undefined if * no special UI or processing is required */ archetype?: string; allowedOnComponents?: string[]; /** Resource path, appended to the data source's baseUrl (e.g. baseUrl = https://base.url, path = /v1/endpoint -> final URL https://base.url/v1/endpoint). Must have a leading slash */ path: string; /** Time-to-live (in seconds) for the resource data cache */ ttl?: number; /** A key for the resource data cache purging */ purgeKey?: string; /** URL to a custom badge icon for the Uniform dashboard for this data type. If not set falls back to the data connector or integration icons */ badgeIconUrl?: string; /** HTTP headers to pass with requests to the data type. Merged with headers from the data source, overriding identical keys */ headers?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Body to pass with requests to the data type (ignored unless the method is POST) */ body?: string; /** * HTTP method to use with requests to the data type * @defaultValue GET */ method: "GET" | "POST" | "HEAD"; /** Variables needed to make calls to the data type. Merged with variables from the data source, overriding identical keys */ variables?: { [key: string]: components$q["schemas"]["DataVariableDefinition"]; }; /** Custom configuration specific to the data source being defined */ custom?: { [key: string]: unknown; }; /** Created date of the data type in ISO 8601 format (ignored for writes) */ created?: string; /** Last modified date of the data type in ISO 8601 format (ignored for writes) */ modified?: string; /** User or API key ID that created the data type (ignored for writes) */ createdBy?: string; /** User or API key ID that last modified the data type (ignored for writes) */ modifiedBy?: string; }; /** Defines the shape of a data variable on a Data Source or Data Type */ DataVariableDefinition: { /** Display name of the data variable */ displayName?: string; /** Explanatory text that is provided to the data resource editor to explain what this variable does */ helpText?: string; /** * Type of the data variable. Optionally used as a point of reference for custom integrations to decide how to render an editor for a variable * @defaultValue text */ type?: string; /** Default value of the data variable */ default: string; /** Sets the order of the variable when displayed in a list with other variables. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; /** * An optional arbitrary human readable source identifier to describe where this variable is from. * Some user interfaces may group variables by source value, for example 'From URL' or 'My Integration' */ source?: string; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$q["schemas"]["DataResourceDefinition"]; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$q["schemas"]["DataResourceVariables"]; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; HistoryApiResponse: { /** * If there are more results, this will be populated with a token to pass in the next request to get the next page of results. * If this is undefined then no more results are available */ cursor?: string; /** If more history is available than your plan allows, and additional entries are available by upgrading, this will be true */ truncated?: boolean; /** Version history entries */ results?: components$q["schemas"]["HistoryEntry"][]; }; HistoryEntry: { /** The version ID of the entity. This can be used to fetch the version's data via the entity API */ versionId: string; /** The timestamp when the version was created in epoch milliseconds */ timestamp: number; /** The name (full name) of the user who created the version, or "Unknown user" if the author can no longer be resolved */ authorName: string; authorIsApiKey: boolean; /** The identity who created the version; absent on old history entries. */ authorSubject?: string; /** The state of the entity when the history entry was made */ state: number; }; /** Category for tagging canvas entities */ Category: { /** * Format: uuid * Unique identifier for the category */ id: string; /** Display name of the category */ name: string; /** * Sets the order of the category when displayed in a list with other categories. If not set, the order defaults to alphabetical with any explicitly set orders first in the list * @defaultValue 0 */ order?: number; }; /** Project map node information related to a component */ CompositionProjectMapNodeInfo: { /** * Format: uuid * Unique identifier for the project map node */ id: string; /** * Fallback path of the project map node. * Note that the node may have matched via a locale-specific path which is in the `locales` object */ path: string; /** * Format: uuid * Unique identifier for the project map that this node belongs to */ projectMapId: string; data?: components$q["schemas"]["ProjectMapNodeData"]; /** * Locale-specific paths of the project map node. * Keys are locale codes */ locales?: { [key: string]: { /** Locale-specific path of the project map node */ path: string; /** Whether the path is inherited from a parent node which defined a path segment in this locale */ inherited: boolean; }; }; }; /** AI Prompt definition */ Prompt: { /** * Format: uuid * Unique identifier for the prompt */ id: string; /** Unique identifier for the integration that this prompt belongs to */ integrationType: string; /** Name for the prompt */ name?: string | null; /** Text for the prompt */ text?: string | null; /** Data for the prompt */ data?: { [key: string]: unknown; } | null; /** Turn off/on prompt */ enabled?: boolean | null; /** Integration default prompt */ builtIn?: boolean | null; /** Supported parameter types */ parameterTypes?: string[] | null; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$q["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$q["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$q["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$q["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** @enum {string} */ ReleaseState: "open" | "locked" | "queued" | "launching" | "launched" | "deleting"; /** @enum {string} */ ReleaseScheduleState: "scheduled" | "unscheduled"; ProjectMapNodeAllowedQueryString: { /** The name of the query string parameter */ name: string; /** The default value of the query string if it is not provided by an incoming route path */ value?: string; /** Help text for authors who might be setting up a preview value for this query string */ helpText?: string; /** * Controls whether a global query string is always shown in Canvas or must be opted into. * This property is ignored on node-level query strings. When omitted, the query string is always shown. */ editorVisibility?: "opt-in"; /** Configuration for providing a list of allowed values for this query string */ optionsSource?: { /** * The source type for the options */ source: "static"; options: { /** Display name for the option */ name: string; /** The actual value to be used */ value: string; }[]; }; }; ProjectMapNodeData: { /** While performing a search if a node is a hit, this property will return true. If it's supporting structure, like a parent of a search hit, it will return false */ isSearchHit?: boolean; /** Query strings that are allowed to be passed to the node */ queryStrings?: components$q["schemas"]["ProjectMapNodeAllowedQueryString"][]; /** * For dynamic nodes, this is the preview value for the dynamic value. * The preview value is used when editing a connected composition, and is the default * dynamic node value unless the author has explicitly chosen a different value */ previewValue?: string; }; }; responses: never; parameters: never; requestBodies: never; headers: never; pathItems: never; } type SharedComponents$3 = components$q['schemas']; type Api$2 = paths$n['/api/v1/categories']; /** Shape of the GET response from /api/v1/category */ type CategoriesGetResponse = Api$2['get']['responses']['200']['content']['application/json']; /** Shape of the PUT request body for /api/v1/category */ type CategoriesPutParameters = Api$2['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/category */ type CategoriesDeleteParameters = Api$2['delete']['requestBody']['content']['application/json']; /** Query parameter options for GET /api/v1/category */ type CategoriesGetParameters = Api$2['get']['parameters']['query']; /** Defines a component type that can live on a Composition */ type Category = SharedComponents$3['Category']; declare class CategoryClient extends ApiClient { constructor(options: ClientOptions); /** Fetches a list of categories created in given project */ list(options?: Omit): Promise<{ categories: components$r["schemas"]["Category"][]; }>; /** @deprecated Use {@link list} instead. */ getCategories(options?: Omit): Promise<{ categories: components$r["schemas"]["Category"][]; }>; /** Updates or creates a category, also used to re-order them */ save(categories: CategoriesPutParameters['categories']): Promise; /** @deprecated Use {@link save} instead. */ upsertCategories(categories: CategoriesPutParameters['categories']): Promise; /** Deletes a category */ remove(options: Omit): Promise; /** @deprecated Use {@link remove} instead. */ removeCategory(options: Omit): Promise; } /** @deprecated Pass `bypassCache: true` to {@link CategoryClient} instead. */ declare class UncachedCategoryClient extends CategoryClient { constructor(options: Omit); } interface paths$m { "/api/v1/canvas-definitions": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { /** The project ID to get component definitions for */ projectId: string; /** Limit the list to one result by ID (response remains an array) */ componentId?: string; /** Number of records to skip */ offset?: number; /** Maximum number of records to return */ limit?: number; /** Whether to fetch system meta-component definitions (personalize, test, etc.) */ includeSystem?: boolean; /** Filter by category ID */ categories?: string[]; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { /** Component definitions that match the query */ componentDefinitions: components$p["schemas"]["ComponentDefinition"][]; }; }; }; 400: components$p["responses"]["BadRequestError"]; 401: components$p["responses"]["UnauthorizedError"]; 403: components$p["responses"]["ForbiddenError"]; 429: components$p["responses"]["RateLimitError"]; 500: components$p["responses"]["InternalServerError"]; }; }; /** Upserts a component definition */ put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** * Format: uuid * The project ID to upsert the component definition to */ projectId: string; componentDefinition: components$p["schemas"]["ComponentDefinition"]; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$p["responses"]["BadRequestError"]; 401: components$p["responses"]["UnauthorizedError"]; 403: components$p["responses"]["ForbiddenError"]; 429: components$p["responses"]["RateLimitError"]; 500: components$p["responses"]["InternalServerError"]; }; }; post?: never; /** Deletes a component definition */ delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** The public ID of the component definition to delete */ componentId: string; /** * Format: uuid * The project ID the component definition to delete belongs to */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$p["responses"]["BadRequestError"]; 401: components$p["responses"]["UnauthorizedError"]; 403: components$p["responses"]["ForbiddenError"]; 429: components$p["responses"]["RateLimitError"]; 500: components$p["responses"]["InternalServerError"]; }; }; /** Handles preflight requests. This endpoint allows CORS */ options: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; }; }; head?: never; patch?: never; trace?: never; }; } interface components$p { schemas: { /** Public ID (used in code). Do not change after creation */ PublicIdProperty: string; /** The definition of a component parameter */ ComponentDefinitionParameter: { id: components$p["schemas"]["PublicIdProperty"]; /** Friendly name of the parameter */ name: string; /** Appears next to the parameter in the Composition editor */ helpText?: string; /** Context provided to AI when generating content for this parameter. May also be shown to humans. */ guidance?: string; /** Type name of the parameter (provided by a Uniform integration) */ type: string; /** * If true, this property can have locale-specific values. If false or not defined, * this property will have a single value that is shared for all locales */ localizable?: boolean; /** * When `localizable` is true, this property controls the default localizability of the property. * true - when the property has no existing value, it will be in 'single value' mode and not store locale specific values * false/undefined - when the property has no existing value, it will store separate values for each enabled locale * * If `localized` is false, this has no effect. */ notLocalizedByDefault?: boolean; /** * Enables creating additional conditional values for the parameter based on criteria such as dynamic inputs. * When combined with a localized value, each locale has independent conditional values. * * When not defined, conditional values are not allowed. */ allowConditionalValues?: boolean; /** The configuration object for the type (type-specific) */ typeConfig?: unknown; }; /** Permission set for a component definition */ ComponentDefinitionPermission: { roleId: components$p["schemas"]["PublicIdProperty"]; /** * Permission type for this permission ComponentDefinition: * read | write | create | delete */ permission: "read" | "write" | "create" | "delete"; /** State of the component that this permission applies to */ state: number; }; /** The definition of a named component slot that can contain other components */ ComponentDefinitionSlot: { id: components$p["schemas"]["PublicIdProperty"]; /** Friendly name of the slot */ name: string; /** A list of component definition public IDs that are allowed in this named slot */ allowedComponents: string[]; /** * Whether this slot inherits its allowed components from the parent slot it lives in. If true, `allowedComponents` is irrelevant. * If `allowAllComponents` is true, this value is ignored * @defaultValue false */ inheritAllowedComponents: boolean; /** * When false or not defined, only components in `allowedComponents` may be added to this slot - and if `allowedComponents` is empty, nothing can be added. * When true, every component and pattern that is defined may be added to this slot regardless of any other setting including `inheritAllowedComponents` */ allowAllComponents?: boolean; /** * When not defined, or false: all patterns for components listed in `allowedComponents` are automatically allowed in the slot. * When true: patterns for components listed in `allowedComponents` are not allowed in the slot unless explicitly added to `allowedComponents` as `$p:` */ patternsInAllowedComponents?: boolean; /** Minimum valid number of components in this slot */ minComponents?: number; /** Maximum valid number of components in this slot */ maxComponents?: number; }; /** The definition of a composition's slug settings */ ComponentDefinitionSlugSettings: { /** * Whether the slug is required * no: slug is optional * yes: slug is required * disabled: slug is disabled and will not be shown in the editor * @defaultValue no */ required?: "no" | "yes" | "disabled"; /** * Slug uniqueness configuration. * no = no unique constraint * local = must be unique within this component type * global = must be unique across all component types */ unique?: "no" | "local" | "global"; /** Regular expression slugs must match */ regularExpression?: string; /** * Custom error message when regular expression validation fails. * Has no effect if `regularExpression` is not set */ regularExpressionMessage?: string; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$p["schemas"]["VisibilityCriteria"] | components$p["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$p["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$p["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$p["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$p["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$p["schemas"]["ComponentParameterConditions"]; }; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$p["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$p["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$p["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$p["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$p["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$p["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$p["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$p["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$p["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$p["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$p["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$p["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$p["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$p["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** The definition of a component variant */ ComponentDefinitionVariant: { id: components$p["schemas"]["PublicIdProperty"]; /** Friendly name of the variant */ name: string; }; /** Defines a component type that can live on a Composition */ ComponentDefinition: { id: components$p["schemas"]["PublicIdProperty"]; /** Friendly name of the component definition */ name: string; /** * Icon name for the component definition (e.g. 'screen') * @defaultValue screen */ icon?: string; /** * The public ID of the parameter whose value should be used to create a display title for this component in the UI. * The parameter type must support being used as a title parameter for this to work * @defaultValue null */ titleParameter?: string | null; /** * The public ID of the parameter whose value should be used as a thumbnail for compositions of this component in the UI * @defaultValue null */ thumbnailParameter?: string | null; /** * Whether this component type can be the root of a composition. If false, this component is only used within slots on other components * @defaultValue false */ canBeComposition?: boolean; /** The parameters for this component. Parameters are key-value pairs that can be anything from text values to links to CMS entries */ parameters?: components$p["schemas"]["ComponentDefinitionParameter"][]; /** * Format: uuid * Reference to the category this component definition belongs to * @defaultValue null */ categoryId?: string | null; /** Description of the component definition */ description?: string; /** Preview image URL for the component definition (shown in the UI) */ previewImageUrl?: string; /** * if this component uses team permissions or custom permissions * @defaultValue true */ useTeamPermissions?: boolean; /** Custom role permissions for this component definition */ permissions?: components$p["schemas"]["ComponentDefinitionPermission"][]; /** The named slots for this component; placement areas where arrays of other components can be added */ slots?: components$p["schemas"]["ComponentDefinitionSlot"][]; slugSettings?: components$p["schemas"]["ComponentDefinitionSlugSettings"]; /** Default component instance value */ defaults?: components$p["schemas"]["ComponentInstance"] | null; /** Named variants for this component; enables the creation of visual variants that use the same parameter data */ variants?: components$p["schemas"]["ComponentDefinitionVariant"][]; /** Created date string for this definition (ignored for writes) */ created?: string; /** Last modified date string for this definition (ignored for writes) */ updated?: string; /** * Format: uuid * ID of the workflow that instances of this component definition will use by default. When not set, no workflow is attached */ workflowId?: string; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$p["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$p["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$p["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } type SharedComponents$2 = components$q['schemas']; type Api$1 = paths$m['/api/v1/canvas-definitions']; /** Shape of the GET response from /api/v1/canvas-definitions */ type ComponentDefinitionGetResponse = Api$1['get']['responses']['200']['content']['application/json']; /** Shape of the PUT request body for /api/v1/canvas-definitions */ type ComponentDefinitionPutParameters = Api$1['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/canvas-definitions */ type ComponentDefinitionDeleteParameters = Api$1['delete']['requestBody']['content']['application/json']; /** Query parameter options for GET /api/v1/canvas-definitions */ type ComponentDefinitionGetParameters = Api$1['get']['parameters']['query']; /** The definition of a component parameter */ type ComponentDefinitionParameter = Omit & { typeConfig?: TConfig; }; /** The definition of a component visual variant */ type ComponentDefinitionVariant = SharedComponents$2['ComponentDefinitionVariant']; /** The definition of a composition's slug settings */ type ComponentDefinitionSlugSettings = SharedComponents$2['ComponentDefinitionSlugSettings']; /** The definition of a named component slot that can contain other components */ type ComponentDefinitionSlot = SharedComponents$2['ComponentDefinitionSlot']; /** Permission set for a component defintion */ type ComponentDefinitionPermission = SharedComponents$2['ComponentDefinitionPermission']; /** Defines a component type that can live on a Composition */ type ComponentDefinition = SharedComponents$2['ComponentDefinition']; /** * Internal base for the canvas content clients: applies a default limit policy * and the per-client `bypassCache` default. Not exported from the package surface. */ declare abstract class ContentClientBase extends ApiClient { protected constructor(options: ClientOptions, defaultBypassCache: boolean); } /** * Management client for component definitions. */ declare class ComponentDefinitionClient extends ContentClientBase { constructor(options: ClientOptions); /** Fetches one component definition by id (throws `ApiClientError(404)` if absent). */ get(args: { componentId: string; }): Promise; /** Fetches a list of component definitions. */ list(args?: ExceptProject): Promise; /** Creates or updates a component definition. */ save(def: ExceptProject): Promise; /** Deletes a component definition. */ remove(args: ExceptProject): Promise; } /** Public ID of Canvas personalization component type */ declare const CANVAS_PERSONALIZE_TYPE = "$personalization"; /** Public ID of Canvas A/B test component type */ declare const CANVAS_TEST_TYPE = "$test"; /** Public ID of Canvas localization component type */ declare const CANVAS_LOCALIZATION_TYPE = "$localization"; /** Public ID of Canvas slot section component type */ declare const CANVAS_SLOT_SECTION_TYPE = "$slotSection"; /** Public ID of the intent tag parameter on the Canvas personalization component type */ declare const CANVAS_INTENT_TAG_PARAM = "intentTag"; /** Public ID of the locale parameter on Canvas components */ declare const CANVAS_LOCALE_TAG_PARAM = "locale"; /** Parameter type for a block parameter */ declare const CANVAS_BLOCK_PARAM_TYPE = "$block"; /** Name of the slot on CANVAS_PERSONALIZE_TYPE */ declare const CANVAS_PERSONALIZE_SLOT = "pz"; /** Name of the slot on CANVAS_TEST_TYPE */ declare const CANVAS_TEST_SLOT = "test"; /** Name of the slot on CANVAS_TEST_TYPE */ declare const CANVAS_LOCALIZATION_SLOT = "localized"; /** Name of the slot on CANVAS_SLOT_SECTION_TYPE */ declare const CANVAS_SLOT_SECTION_SLOT = "$slotSectionItems"; /** Name of the 'name' parameter on CANVAS_SLOT_SECTION_TYPE */ declare const CANVAS_SLOT_SECTION_NAME_PARAM = "name"; /** Name of the 'min' parameter on CANVAS_SLOT_SECTION_TYPE */ declare const CANVAS_SLOT_SECTION_MIN_PARAM = "min"; /** Name of the 'max' parameter on CANVAS_SLOT_SECTION_TYPE */ declare const CANVAS_SLOT_SECTION_MAX_PARAM = "max"; /** Name of the 'groupType' parameter on CANVAS_SLOT_SECTION_TYPE */ declare const CANVAS_SLOT_SECTION_GROUP_TYPE_PARAM = "groupType"; /** Name of the 'specific' parameter on CANVAS_SLOT_SECTION_TYPE */ declare const CANVAS_SLOT_SECTION_SPECIFIC_PARAM = "specific"; /** Constant for a draft composition state. Subject to change. */ declare const CANVAS_DRAFT_STATE = 0; /** Constant for a published composition state. Subject to change. */ declare const CANVAS_PUBLISHED_STATE = 64; /** Constant for editor composition state. */ declare const CANVAS_EDITOR_STATE = 63; /** Public ID of the Uniform Context personalization criteria parameter on Canvas components */ declare const CANVAS_PERSONALIZATION_PARAM = "$pzCrit"; /** Public ID of the Uniform Context personalization component's event name parameter */ declare const CANVAS_PERSONALIZATION_EVENT_NAME_PARAM = "trackingEventName"; /** Public ID of the Uniform Context personalization component's algorithm parameter */ declare const CANVAS_PERSONALIZATION_ALGORITHM_PARAM = "algorithm"; /** Type value for the personalization algorithm parameter */ declare const CANVAS_PERSONALIZATION_ALGORITHM_TYPE = "pzAlgorithm"; /** Public ID of the Uniform Context personalization component's number of variants to show parameter */ declare const CANVAS_PERSONALIZATION_TAKE_PARAM = "count"; /** Public ID of the Uniform Context test variant parameter on Canvas components */ declare const CANVAS_TEST_VARIANT_PARAM = "$tstVrnt"; /** Public ID of the Uniform Context enrichment tag parameter on Canvas components */ declare const CANVAS_ENRICHMENT_TAG_PARAM = "$enr"; /** Prefix for author-reference parameters that are automatically removed during delivery from uniform.global */ declare const CANVAS_INTERNAL_PARAM_PREFIX = "$internal_"; /** Public ID of the author-reference display name parameter. This lets authors set a custom display name for the component in the editor. Not delivered via the delivery API. */ declare const CANVAS_COMPONENT_DISPLAY_NAME_PARAM = "$internal_displayName"; /** Public ID of Context hypothesis parameter. This lets authors set a custom hypothesis for A/B tests or Personalization in the editor. Not delivered via the delivery API. */ declare const CANVAS_HYPOTHESIS_PARAM = "$internal_hypothesis"; /** * @deprecated Use a supported Canvas parameter instead of the contextual editing param. * Public ID of Contextual Editing parameter on Canvas components */ declare const CANVAS_CONTEXTUAL_EDITING_PARAM = "$contextualEditing"; /** * The name of the query string used to set a secret to protect for the preview mode. * This is not configurable at the moment. */ declare const SECRET_QUERY_STRING_PARAM = "secret"; /** The name of the query string used to detect if we are in contextual editing mode */ declare const IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode"; /** The name of the query string used to indicate that we want to use the playground for preview */ declare const IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM = "is_incontext_editing_playground"; /** The name of the query string used to detect if we are in contextual editing mode */ declare const IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM = "is_incontext_editing_forced_settings"; /** The name of the query string used to get the config from the preview url */ declare const IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM = "is_config_check"; /** The value of "data-role" on the component start marker element */ declare const IN_CONTEXT_EDITOR_COMPONENT_START_ROLE = "uniform-component-start"; /** The value of "data-role" on the component end marker element */ declare const IN_CONTEXT_EDITOR_COMPONENT_END_ROLE = "uniform-component-end"; /** The ID of the Contextual Editing script that gets embedded in frontend apps */ declare const IN_CONTEXT_EDITOR_EMBED_SCRIPT_ID = "uniform-canvas-preview-script"; /** * The name of the attribute added to the elements rendered by Uniform. * Use to allow interacting with them by default in the preview panel */ declare const IS_RENDERED_BY_UNIFORM_ATTRIBUTE = "data-is-rendered-by-uniform"; /** The ID we give to placeholder components */ declare const PLACEHOLDER_ID = "placeholder"; /** Contextual editing empty composition, used as a placeholder while waiting for the composition to be send by the editor. */ declare const EMPTY_COMPOSITION: { _id: string; _name: string; type: string; }; /** Minimal value for Edgehancers Cache TTL (in seconds) */ declare const EDGE_MIN_CACHE_TTL = 10; /** Maximal value for Edgehancers Cache TTL (in seconds) */ declare const EDGE_MAX_CACHE_TTL: number; /** Default value for Edgehancers Cache TTL (in seconds) */ declare const EDGE_DEFAULT_CACHE_TTL = 30; /** A value that indicates that Edgehancers caching is disabled */ declare const EDGE_CACHE_DISABLED = -1; /** This is the type value for the asset parameter or field */ declare const ASSET_PARAMETER_TYPE = "asset"; /** The _source for any assets coming from the Uniform Asset Library */ declare const ASSETS_SOURCE_UNIFORM = "uniform-assets"; /** The _source for any assets which have manually set fields */ declare const ASSETS_SOURCE_CUSTOM_URL = "custom-url"; /** The data type ID for internal content references (entry-to-entry relationships) */ declare const REFERENCE_DATA_TYPE_ID = "uniformContentInternalReference"; interface components$o { schemas: { /** Defines the shape of the entry */ Entry: { /** Content type public ID of the entry */ type: string; /** * Format: uuid * The ID of the entry */ _id: string; /** The name of the entry */ _name?: string; /** The thumbnail URL of the entry */ _thumbnail?: string; /** The slug of the entry */ _slug?: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this content entry should be sourced from a pattern library pattern */ _pattern?: string; /** Array of locales that have data defined on the entry. If empty, the current default locale implicitly has data */ _locales?: string[]; /** Entry field values */ fields?: { [key: string]: components$o["schemas"]["ComponentParameter"]; }; _dataResources?: components$o["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$o["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, or not been published yet. * Means nothing for PUTs; it will be ignored */ _patternError?: "NOTFOUND" | "CYCLIC"; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$o["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$o["schemas"]["ComponentOverridability"]; }; /** Defines the shape of the entry input */ EntryInput: { /** Content type of the entry */ type: string; /** * Format: uuid * The public UUID of the entry */ _id?: string; /** The name of the entry */ _name?: string; /** The slug of the entry */ _slug?: string; /** The thumbnail URL of the entry */ _thumbnail?: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Entry field values */ fields?: { [key: string]: components$o["schemas"]["ComponentParameter"]; }; _dataResources?: components$o["schemas"]["DataResourceDefinitions"]; /** Indicates this content entry should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$o["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, or not been published yet. * Means nothing for PUTs; it will be ignored */ _patternError?: "NOTFOUND" | "CYCLIC"; /** * Defines patch overrides for the content entry fields. * This can be used to override fields that are defined on patterns. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$o["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's fields may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$o["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the entry. If empty, the current default locale implicitly has data */ _locales?: string[]; }; EntryApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * Format: uuid * The release this entry belongs to. If not set, the entry belongs to the base */ releaseId?: string; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Only present when `withUIStatus` option is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous"; /** * Format: uuid * The project ID that this layout data is part of */ projectId: string; /** * Format: date-time, * Created date string for this definition */ created: string; /** * Format: date-time, * Modified date string for this definition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** * True if the entry is a pattern (which can be referenced on other entries) * @defaultValue false */ pattern?: boolean; entry: components$o["schemas"]["Entry"]; /** * Format: uuid * The workflow ID that this entry is assigned. Normally comes from the content type */ workflowId?: string; /** * Format: uuid * The stage ID the entry is in on its assigned workflow. When undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Only returned when `withWorkflowDefinition` is true */ workflowDefinition?: components$o["schemas"]["WorkflowDefinition"]; /** * Only present if an incomplete entry is returned; indicates reason for stubbing */ stubType?: "missing" | "tooDeep"; /** * Format: uuid * The edition ID. When set, this is a child edition of the entry in _id. */ editionId?: string; /** * The name of the entry or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or entry. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; EntryListResponse: { entries: components$o["schemas"]["EntryApiResponse"][]; /** Total number of entries that match the query. Only present when `withTotalCount` option is true */ totalCount?: number; /** Per-field counts for distinct values */ facets?: { [key: string]: { [key: string]: number; }; }; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$o["schemas"]["VisibilityCriteria"] | components$o["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$o["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$o["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$o["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$o["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$o["schemas"]["ComponentParameterConditions"]; }; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$o["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$o["schemas"]["DataResourceDefinition"]; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$o["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$o["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$o["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$o["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$o["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$o["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$o["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$o["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$o["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$o["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$o["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$o["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$o["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$o["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$o["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$o["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; }; responses: never; parameters: { /** The project the entry/entries are on */ projectId: string; /** * Specify one or more entry IDs to fetch. * When `editions=raw`, this matches on edition IDs or entry IDs and edition resolution is disabled. * When `versionId` is passed, this parameter is required and must contain only one entry ID. */ entryIDs: string[]; /** * Specify a historical entry version ID to fetch (retrieved from the entries-history API). * Must be used with the `entryIDs` parameter, and there must be only one entryID passed */ versionId: string; /** Specify a single entry to fetch by slug */ slug: string; /** The content type ID to filter by */ type: string[]; /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** Number of records to skip */ offset: number; /** Max number of records to return */ limit: number; /** * Sets the sorting of the results. If unspecified, results are sorted by modification date descending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, name_DESC, name_ASC, slug_DESC, slug_ASC */ orderBy: string[]; /** * @deprecated * Returns counts for distinct values of the specified field or fields (provided as comma-separated IDs). */ facetBy: string; /** * @deprecated * Returns the UI status string of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ withUIStatus: boolean; /** Returns the definition of any attached workflow along with the entry data */ withWorkflowDefinition: boolean; /** * If true the `_id` unique identifier of blocks will be part of the response data. * If false, the `_id` will not be present in the API response. * Note: the default value depends on the `format`: true for editor or canonical, false for delivery or when no format is specified. * Prefer selecting a `format` rather than using this option. */ withComponentIDs: boolean; /** * @deprecated * Filters entries lists by the UI status of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ uiStatus: ("Draft" | "Modified" | "Published" | "Orphan")[]; /** Filters entry lists by the user who created them. The user is specified by their identity subject */ createdBy: string; /** Filters entry lists by the user who last updated them. The user is specified by their identity subject */ updatedBy: string; /** * Controls whether the total count of results will be returned along with the current results page in a list. * Has no effect when not fetching a list. This does impact performance when enabled */ withTotalCount: boolean; /** Performs keyword search on the entries */ keyword: string; /** * Specify a format you want the results in. Any explicit shaping flag (skipPatternResolution, * skipOverridesResolution, withComponentIDs, skipContentTypeResolution) overrides this alias. * - `canonical`: PUT-safe structure — patterns and overrides left * unresolved and component `_id`s included. This is the format the Uniform CLI uses when syncing. * (skipPatternResolution=true, skipOverridesResolution=true, * withComponentIDs=true, skipContentTypeResolution=false). * - `editor`: For loading into a Uniform editor - same as canonical, but with patterns expanded (skipPatternResolution=false). Still PUT-safe — the PUT ignores * the expanded pattern nodes. * - `delivery`: default structure for serving to a frontend — patterns and overrides resolved, * component `_id`s removed, and each entry returned as stored * (skipContentTypeResolution=true). */ format: "canonical" | "editor" | "delivery"; /** * Improves performance by skipping dynamic data revalidations; appropriate for content delivery. * Default: true when `format` is delivery. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipContentTypeResolution: boolean; /** * If true, any pattern references in the composition will be left unresolved. * This is appropriate if you intend to serialize the composition without patterns * embedded into it, and serialize the pattern data separately. * Default: true when `format` is canonical. False otherwise * Prefer selecting a `format` rather than using this option. */ skipPatternResolution: boolean; /** * If true, any pattern override data is not resolved by the API. * This is intended for internal use in the Canvas editor, and should not be used. * Passing this parameter automatically implies withComponentIDs to be true. * Default: true when `format` is canonical or editor. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipOverridesResolution: boolean; /** * @deprecated * This parameter is unused and has no effect. Passing this parameter will become an error in the future */ skipParameterResolution: boolean; /** * Matches entries based on whether they are pattern entries or regular entries. * If true, only pattern entries will be returned. * If false (default), only regular entries will be returned. * If 'any', both pattern and regular entries will be returned (useful for ID lookups). */ pattern: boolean | "any"; /** * One or more locales to filter and localize by. * Only entries that enable one of the specified locales _or enable no locales_ will be returned. * The response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned */ locale: string; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId: string; /** * Search on textual fields of an entry. * Matches against fully rendered content including resolved pattern content. * Use this for "where does this content appear" queries. * Note: For long text fields, the tail of the text is not guaranteed to be searchable. * Example: ?search=hello */ search: string; /** * @deprecated * BETA: Semantic search using vector similarity to find content by meaning. * Matches against source content only - pattern base content matches the pattern itself, not consumers. * Use this for "where is this content defined" queries. * Requires AI credits. */ searchSemantic: string; /** * Controls the edition resolution behavior. * * auto: (default) Editions are evaluated automatically and the best matching edition is returned. * When a locale is provided, the edition with the highest priority that enables that locale matches * Without a locale, the default edition is matched * * all: Every edition is returned as a separate row. * * raw: the entryIDs parameter targets exact edition/entry IDs and no edition resolution is performed. * entryIDs MUST be provided with this option. * If versionId is passed, this is always enabled. */ editions: "auto" | "all" | "raw"; /** * Controls filtering of trashed items. * * exclude: (default) Only return items not in trash. * only: Only return trashed items (for trash view). * include: Return both trashed and non-trashed items. */ deleted: "exclude" | "only" | "include"; }; requestBodies: never; headers: never; pathItems: never; } interface paths$l { "/api/v1/content-types": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { /** The project ID to get content type for */ projectId: string; /** Number of records to skip */ offset?: number; /** Max number of records to return */ limit?: number; /** Limit the types of content type to return. If not specified, both block types and content types are returned */ type?: "block" | "contentType"; /** Limit the response to the content types (or block types) matching these public IDs. */ contentTypeIDs?: string[]; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { /** Content types that match the query */ contentTypes: components$n["schemas"]["ContentType"][]; }; }; }; 400: components$n["responses"]["BadRequestError"]; 401: components$n["responses"]["UnauthorizedError"]; 403: components$n["responses"]["ForbiddenError"]; 429: components$n["responses"]["RateLimitError"]; 500: components$n["responses"]["InternalServerError"]; }; }; /** Upserts a content type */ put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** * Format: uuid * The project ID to upsert the content type to */ projectId: string; contentType: components$n["schemas"]["ContentType"]; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$n["responses"]["BadRequestError"]; 401: components$n["responses"]["UnauthorizedError"]; 403: components$n["responses"]["ForbiddenError"]; 429: components$n["responses"]["RateLimitError"]; 500: components$n["responses"]["InternalServerError"]; }; }; post?: never; /** Deletes a content type */ delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** The public ID of the content type to delete */ contentTypeId: string; /** * Format: uuid * The ID of the project the content type to delete belongs to */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$n["responses"]["BadRequestError"]; 401: components$n["responses"]["UnauthorizedError"]; 403: components$n["responses"]["ForbiddenError"]; 429: components$n["responses"]["RateLimitError"]; 500: components$n["responses"]["InternalServerError"]; }; }; /** Handles preflight requests. This endpoint allows CORS */ options: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; }; }; head?: never; patch?: never; trace?: never; }; } interface components$n { schemas: { /** Public ID (used in code). Do not change after creation */ PublicIdProperty: string; /** The definition of a component parameter */ ComponentDefinitionParameter: { id: components$n["schemas"]["PublicIdProperty"]; /** Friendly name of the parameter */ name: string; /** Appears next to the parameter in the Composition editor */ helpText?: string; /** Context provided to AI when generating content for this parameter. May also be shown to humans. */ guidance?: string; /** Type name of the parameter (provided by a Uniform integration) */ type: string; /** * If true, this property can have locale-specific values. If false or not defined, * this property will have a single value that is shared for all locales */ localizable?: boolean; /** * When `localizable` is true, this property controls the default localizability of the property. * true - when the property has no existing value, it will be in 'single value' mode and not store locale specific values * false/undefined - when the property has no existing value, it will store separate values for each enabled locale * * If `localized` is false, this has no effect. */ notLocalizedByDefault?: boolean; /** * Enables creating additional conditional values for the parameter based on criteria such as dynamic inputs. * When combined with a localized value, each locale has independent conditional values. * * When not defined, conditional values are not allowed. */ allowConditionalValues?: boolean; /** The configuration object for the type (type-specific) */ typeConfig?: unknown; }; /** The definition of a composition's slug settings */ ComponentDefinitionSlugSettings: { /** * Whether the slug is required * no: slug is optional * yes: slug is required * disabled: slug is disabled and will not be shown in the editor * @defaultValue no */ required?: "no" | "yes" | "disabled"; /** * Slug uniqueness configuration. * no = no unique constraint * local = must be unique within this component type * global = must be unique across all component types */ unique?: "no" | "local" | "global"; /** Regular expression slugs must match */ regularExpression?: string; /** * Custom error message when regular expression validation fails. * Has no effect if `regularExpression` is not set */ regularExpressionMessage?: string; }; /** Permission set for a component definition */ ComponentDefinitionPermission: { roleId: components$n["schemas"]["PublicIdProperty"]; /** * Permission type for this permission ComponentDefinition: * read | write | create | delete */ permission: "read" | "write" | "create" | "delete"; /** State of the component that this permission applies to */ state: number; }; /** Defines a configuration for previewing an entry on a consuming pattern or composition. */ ContentTypePreviewConfiguration: { /** * The type of preview configuration */ type: "pattern" | "project-map"; /** Display label for the preview configuration */ label: string; /** * Format: uuid * Target preview entity ID (project map node ID or pattern ID) */ id: string; /** Optional mapping of dynamic input names to their values */ dynamicInputs?: { [key: string]: string; }; }; /** Defines a content type */ ContentType: { id: components$n["schemas"]["PublicIdProperty"]; /** Friendly name of the content type */ name: string; /** * The public ID of the field whose value should be used to create a display name for entries of this content type in the UI. * The field type must support being used as an entry name for this to work */ entryName?: string | null; /** * The public ID of the field whose value should be used as a thumbnail for entries of this content type in the UI * @defaultValue null */ thumbnailField?: string | null; /** The fields for this content type. Fields are key-value pairs that can be text, numbers, JSON objects, etc. */ fields?: components$n["schemas"]["ComponentDefinitionParameter"][]; /** Description of the content type */ description?: string; /** * Icon name for the content type (e.g. 'screen') * @defaultValue file-document */ icon?: string; /** Created date string for this content type (ignored for writes) */ created?: string; /** Last modified date string for this content type (ignored for writes) */ updated?: string; slugSettings?: components$n["schemas"]["ComponentDefinitionSlugSettings"]; /** * The definition type of this content type (block or content type) * @defaultValue contentType */ type?: "contentType" | "block"; /** * if this content type uses team permissions or custom permissions * @defaultValue true */ useTeamPermissions?: boolean; /** Custom role permissions for this content type */ permissions?: components$n["schemas"]["ComponentDefinitionPermission"][]; /** * Format: uuid * ID of the workflow that instances of this content type will use by default. When not set, no workflow is attached */ workflowId?: string; /** Configurations for previewing an entry on a consuming pattern or composition. */ previewConfigurations?: components$n["schemas"]["ContentTypePreviewConfiguration"][]; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$n["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$n["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$n["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } interface paths$k { "/api/v1/entries": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; /** * In addition to the named parameters below, this endpoint accepts the * following query parameter conventions which are pattern-validated and * therefore not declared as named parameters: * * * `filters.[]` — content filtering (documented below). * * `select.[]` — data projection (documented below). * * #### Content filtering (`filters.*`) * * Filtering narrows list results to entries matching field values. The * allowed field names are project-specific — they come from the project's * content types — which is why `filters.*` parameters are * pattern-validated rather than declared as named parameters. * * Syntax: `filters.[]=`. `` is one of: * * * A system field: `name`, `slug`, `type`, `created`, `modified`, * `entityId`, `editionId`, `releaseId`, `patternId`, `creator`, * `creatorSubject`, `author`, `authorSubject`, `workflowId`, * `workflowStageId`, `categoryId`, `labels`, `labelGroups`, * `uiStatus`, or `locale`. * * An entry field, addressed as `fields.`. Filtering by fields * requires also filtering to a single content type (e.g. * `filters.type[eq]=...`). * * A sub-property of a field for certain field types: content * references (`fields..slug|name|type`), links * (`fields..type|projectMapNodeId`), and assets * (`fields..url|title|description|mediaType`). * * | Operator | Effect | * |---|---| * | `[eq]` / `[neq]` | Exact equality / inequality. | * | `[match]` | Contains (text search) match; text-like fields only. | * | `[starts]` | Prefix match. Value limited to letters, numbers, `_`, `.`, `-`, and spaces. | * | `[lt]` / `[lte]` / `[gt]` / `[gte]` | Comparisons for number, date, and datetime fields (including `created` / `modified`). | * | `[in]` / `[nin]` | Comma-separated list; matches any (OR) / none of the values. | * | `[all]` | Comma-separated list; list-valued fields (e.g. `labels`, multi-selects) must contain every value (AND). | * | `[def]` | `true` or `false`; whether the field has a value at all. | * * Behavior: * * * Values are single strings, or comma-separated lists for `[in]`, * `[nin]`, and `[all]`. Dates accept `YYYY-MM-DD` or a full datetime * string. An empty value is rejected — use `[def]` to test presence. * * Not every operator is valid for every field; the allowed set depends * on the field's type. An unsupported combination returns HTTP 400 * with the supported operators listed. * * Malformed keys, unknown operators, and unknown field names return * HTTP 400. * * Examples: * * * `filters.type[eq]=article` — only entries of type `article`. * * `filters.modified[gte]=2026-01-01` — modified this year. * * `filters.type[eq]=article&filters.fields.brandName[match]=adidas` — field filter scoped to one type. * * `filters.fields.author.slug[eq]=jane-doe` — filter by a referenced entry's slug. * * #### Data projection (`select.*`) * * Projection returns a subset of the response by pruning fields and field * types before values are resolved. The allowed names are project-specific — * they come from the project's content types — which is why `select.*` * parameters are pattern-validated rather than declared as named parameters. * * Syntax: `select.[]=`. Values are comma-separated * lists of names. `*` is the only wildcard and matches zero or more * characters (e.g. `seo_*`). * * | Parameter | Effect | * |---|---| * | `select.fields[only]=a,b` | Keep only the named fields; drop everything else. | * | `select.fields[except]=a,b` | Drop the named fields; keep everything else. | * | `select.fields[locales]=a,b` | For the named fields that survive filtering, return the full per-locale value map instead of only the requested locale's value. | * | `select.fields[blockDepth]=N` | Limit how many levels of block field children are kept. `0` removes all block fields; `preserveAll` prevents projection from trimming fields inside block children. | * | `select.fieldTypes[only]=a,b` | Keep only fields of the named types (type IDs such as `text`, `richText`, `asset`). | * | `select.fieldTypes[except]=a,b` | Drop fields of the named types. | * * The composition-oriented `select.slots.*` operators are also accepted but * have no effect on entry responses (entries have no slots). * * Behavior: * * * Projection applies recursively at every block in the returned entry, * and is forwarded into entries resolved through reference fields. * * When operators combine, all `[only]` sets are intersected first, then * `[except]` sets are subtracted — exclusion always wins. * * Unknown field or type names are silent no-ops (the entry shape is * preserved; non-matching content is simply absent). Unknown operators * return HTTP 400. * * An empty list (`select.fields[only]=`) strips every field; `[except]=*` * is equivalent. * * Examples: * * * `select.fields[only]=title,coverImage` — keep only titles and cover images on every entry in the list. * * `select.fieldTypes[except]=richText` — everything except rich-text fields. * * `select.fields[only]=title,seo_*&select.fields[locales]=seo_*` — lean payload keeping all locales on the SEO fields. */ get: { parameters: { query: { /** * Specify one or more entry IDs to fetch. * When `editions=raw`, this matches on edition IDs or entry IDs and edition resolution is disabled. * When `versionId` is passed, this parameter is required and must contain only one entry ID. */ entryIDs?: components$m["parameters"]["entryIDs"]; /** * Specify a historical entry version ID to fetch (retrieved from the entries-history API). * Must be used with the `entryIDs` parameter, and there must be only one entryID passed */ versionId?: components$m["parameters"]["versionId"]; /** Specify a single entry to fetch by slug */ slug?: components$m["parameters"]["slug"]; /** Filters entry lists by the user who created them. The user is specified by their identity subject */ createdBy?: components$m["parameters"]["createdBy"]; /** Max number of records to return */ limit?: components$m["parameters"]["limit"]; /** Number of records to skip */ offset?: components$m["parameters"]["offset"]; /** * Sets the sorting of the results. If unspecified, results are sorted by modification date descending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, name_DESC, name_ASC, slug_DESC, slug_ASC */ orderBy?: components$m["parameters"]["orderBy"]; /** * @deprecated * Returns counts for distinct values of the specified field or fields (provided as comma-separated IDs). */ facetBy?: components$m["parameters"]["facetBy"]; /** * Matches entries based on whether they are pattern entries or regular entries. * If true, only pattern entries will be returned. * If false (default), only regular entries will be returned. * If 'any', both pattern and regular entries will be returned (useful for ID lookups). */ pattern?: components$m["parameters"]["pattern"]; /** The project the entry/entries are on */ projectId: components$m["parameters"]["projectId"]; /** Publishing state to fetch. 0 = draft, 64 = published */ state?: components$m["parameters"]["state"]; /** The content type ID to filter by */ type?: components$m["parameters"]["type"]; /** * @deprecated * Filters entries lists by the UI status of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ uiStatus?: components$m["parameters"]["uiStatus"]; /** Filters entry lists by the user who last updated them. The user is specified by their identity subject */ updatedBy?: components$m["parameters"]["updatedBy"]; /** * Controls whether the total count of results will be returned along with the current results page in a list. * Has no effect when not fetching a list. This does impact performance when enabled */ withTotalCount?: components$m["parameters"]["withTotalCount"]; /** * @deprecated * Returns the UI status string of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ withUIStatus?: components$m["parameters"]["withUIStatus"]; /** Returns the definition of any attached workflow along with the entry data */ withWorkflowDefinition?: components$m["parameters"]["withWorkflowDefinition"]; /** * If true the `_id` unique identifier of blocks will be part of the response data. * If false, the `_id` will not be present in the API response. * Note: the default value depends on the `format`: true for editor or canonical, false for delivery or when no format is specified. * Prefer selecting a `format` rather than using this option. */ withComponentIDs?: components$m["parameters"]["withComponentIDs"]; /** Performs keyword search on the entries */ keyword?: components$m["parameters"]["keyword"]; /** * If true, any pattern references in the composition will be left unresolved. * This is appropriate if you intend to serialize the composition without patterns * embedded into it, and serialize the pattern data separately. * Default: true when `format` is canonical. False otherwise * Prefer selecting a `format` rather than using this option. */ skipPatternResolution?: components$m["parameters"]["skipPatternResolution"]; /** * @deprecated * This parameter is unused and has no effect. Passing this parameter will become an error in the future */ skipParameterResolution?: components$m["parameters"]["skipParameterResolution"]; /** * If true, any pattern override data is not resolved by the API. * This is intended for internal use in the Canvas editor, and should not be used. * Passing this parameter automatically implies withComponentIDs to be true. * Default: true when `format` is canonical or editor. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipOverridesResolution?: components$m["parameters"]["skipOverridesResolution"]; /** * Improves performance by skipping dynamic data revalidations; appropriate for content delivery. * Default: true when `format` is delivery. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipContentTypeResolution?: components$m["parameters"]["skipContentTypeResolution"]; /** * One or more locales to filter and localize by. * Only entries that enable one of the specified locales _or enable no locales_ will be returned. * The response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned */ locale?: components$m["parameters"]["locale"]; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId?: components$m["parameters"]["releaseId"]; /** * Search on textual fields of an entry. * Matches against fully rendered content including resolved pattern content. * Use this for "where does this content appear" queries. * Note: For long text fields, the tail of the text is not guaranteed to be searchable. * Example: ?search=hello */ search?: components$m["parameters"]["search"]; /** * @deprecated * BETA: Semantic search using vector similarity to find content by meaning. * Matches against source content only - pattern base content matches the pattern itself, not consumers. * Use this for "where is this content defined" queries. * Requires AI credits. */ searchSemantic?: components$m["parameters"]["searchSemantic"]; /** * Controls the edition resolution behavior. * * auto: (default) Editions are evaluated automatically and the best matching edition is returned. * When a locale is provided, the edition with the highest priority that enables that locale matches * Without a locale, the default edition is matched * * all: Every edition is returned as a separate row. * * raw: the entryIDs parameter targets exact edition/entry IDs and no edition resolution is performed. * entryIDs MUST be provided with this option. * If versionId is passed, this is always enabled. */ editions?: components$m["parameters"]["editions"]; /** * Specify a format you want the results in. Any explicit shaping flag (skipPatternResolution, * skipOverridesResolution, withComponentIDs, skipContentTypeResolution) overrides this alias. * - `canonical`: PUT-safe structure — patterns and overrides left * unresolved and component `_id`s included. This is the format the Uniform CLI uses when syncing. * (skipPatternResolution=true, skipOverridesResolution=true, * withComponentIDs=true, skipContentTypeResolution=false). * - `editor`: For loading into a Uniform editor - same as canonical, but with patterns expanded (skipPatternResolution=false). Still PUT-safe — the PUT ignores * the expanded pattern nodes. * - `delivery`: default structure for serving to a frontend — patterns and overrides resolved, * component `_id`s removed, and each entry returned as stored * (skipContentTypeResolution=true). */ format?: components$m["parameters"]["format"]; /** * Controls filtering of trashed items. * * exclude: (default) Only return items not in trash. * only: Only return trashed items (for trash view). * include: Return both trashed and non-trashed items. */ deleted?: components$m["parameters"]["deleted"]; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": components$m["schemas"]["EntryListResponse"]; }; }; 400: components$m["responses"]["BadRequestError"]; 401: components$m["responses"]["UnauthorizedError"]; 403: components$m["responses"]["ForbiddenError"]; /** Entry not found */ 404: { headers: { [name: string]: unknown; }; content: { "text/plain": string; }; }; 429: components$m["responses"]["RateLimitError"]; 500: components$m["responses"]["InternalServerError"]; }; }; /** Upserts an entry */ put: { parameters: { query?: never; header?: { /** * Optional concurrency control header. If provided, the server will check that the entry * has not been modified since this timestamp. If the timestamp doesn't match the current * modified timestamp, a 409 Conflict response will be returned. */ "X-If-Unmodified-Since"?: string; }; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** * Format: uuid * The project ID to upsert the entry to */ projectId: string; /** The publishing state to upsert into. 0 = draft, 64 = published */ state: number; entry: components$m["schemas"]["EntryInput"]; /** Ignored if present */ created?: string; /** Ignored if present */ modified?: string; /** * True if the entry is a pattern (which can be referenced on other entries) * @defaultValue false */ pattern?: boolean; /** * Format: uuid * The release this entry belongs to. If not set, the entry belongs to the base */ releaseId?: string; /** * Format: uuid * The workflow ID that this entry is assigned, if any */ workflowId?: string; /** * Format: uuid * The stage ID the entry is in on its assigned workflow. When undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** * Format: uuid * The edition ID. When set, this is a child edition of the entry in _id. */ editionId?: string; /** * The name of the entry or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or entry. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$m["responses"]["BadRequestError"]; 401: components$m["responses"]["UnauthorizedError"]; 403: components$m["responses"]["ForbiddenError"]; /** Conflict - Entry has been changed since being loaded */ 409: { headers: { [name: string]: unknown; }; content: { "text/plain": string; }; }; 429: components$m["responses"]["RateLimitError"]; 500: components$m["responses"]["InternalServerError"]; }; }; post?: never; /** Deletes or unpublishes an entry */ delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** * Format: uuid * The ID of the entry to delete. * When editionId is also passed, the entry remains and an edition under it is deleted. * When editionId is omitted, and the entry has editions, all editions will also be deleted along with the entry. */ entryId: string; /** * Format: uuid * The edition ID to delete. When set, this deletes a child edition of the entryId. * The entry will remain when an edition is deleted. * If the entry ID is specified as the edition ID, the entry will be deleted _but any other editions will remain_ (this is used for unpublishing). */ editionId?: string; /** * Format: uuid * The ID of the project the entry to delete belongs to */ projectId: string; /** * Format: uuid * The ID of the release the entry to delete belongs to. If unspecified the entry belongs to the base. * Note: Deleting an entry from a release will not delete the entry from the base */ releaseId?: string; /** The state to delete (0 = draft, 64 = published [causes unpublishing], unspecified = all) */ state?: number; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$m["responses"]["BadRequestError"]; 401: components$m["responses"]["UnauthorizedError"]; 403: components$m["responses"]["ForbiddenError"]; 429: components$m["responses"]["RateLimitError"]; 500: components$m["responses"]["InternalServerError"]; }; }; /** Handles preflight requests. This endpoint allows CORS */ options: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; }; }; head?: never; patch?: never; trace?: never; }; } interface components$m { schemas: { /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$m["schemas"]["VisibilityCriteria"] | components$m["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$m["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$m["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$m["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$m["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$m["schemas"]["ComponentParameterConditions"]; }; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$m["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$m["schemas"]["DataResourceDefinition"]; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$m["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$m["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$m["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$m["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$m["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$m["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$m["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$m["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$m["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$m["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$m["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$m["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** Defines the shape of the entry */ Entry: { /** Content type public ID of the entry */ type: string; /** * Format: uuid * The ID of the entry */ _id: string; /** The name of the entry */ _name?: string; /** The thumbnail URL of the entry */ _thumbnail?: string; /** The slug of the entry */ _slug?: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this content entry should be sourced from a pattern library pattern */ _pattern?: string; /** Array of locales that have data defined on the entry. If empty, the current default locale implicitly has data */ _locales?: string[]; /** Entry field values */ fields?: { [key: string]: components$m["schemas"]["ComponentParameter"]; }; _dataResources?: components$m["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$m["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, or not been published yet. * Means nothing for PUTs; it will be ignored */ _patternError?: "NOTFOUND" | "CYCLIC"; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$m["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$m["schemas"]["ComponentOverridability"]; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$m["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$m["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$m["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$m["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; EntryApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * Format: uuid * The release this entry belongs to. If not set, the entry belongs to the base */ releaseId?: string; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Only present when `withUIStatus` option is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous"; /** * Format: uuid * The project ID that this layout data is part of */ projectId: string; /** * Format: date-time, * Created date string for this definition */ created: string; /** * Format: date-time, * Modified date string for this definition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** * True if the entry is a pattern (which can be referenced on other entries) * @defaultValue false */ pattern?: boolean; entry: components$m["schemas"]["Entry"]; /** * Format: uuid * The workflow ID that this entry is assigned. Normally comes from the content type */ workflowId?: string; /** * Format: uuid * The stage ID the entry is in on its assigned workflow. When undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Only returned when `withWorkflowDefinition` is true */ workflowDefinition?: components$m["schemas"]["WorkflowDefinition"]; /** * Only present if an incomplete entry is returned; indicates reason for stubbing */ stubType?: "missing" | "tooDeep"; /** * Format: uuid * The edition ID. When set, this is a child edition of the entry in _id. */ editionId?: string; /** * The name of the entry or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or entry. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; EntryListResponse: { entries: components$m["schemas"]["EntryApiResponse"][]; /** Total number of entries that match the query. Only present when `withTotalCount` option is true */ totalCount?: number; /** Per-field counts for distinct values */ facets?: { [key: string]: { [key: string]: number; }; }; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; /** Defines the shape of the entry input */ EntryInput: { /** Content type of the entry */ type: string; /** * Format: uuid * The public UUID of the entry */ _id?: string; /** The name of the entry */ _name?: string; /** The slug of the entry */ _slug?: string; /** The thumbnail URL of the entry */ _thumbnail?: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Entry field values */ fields?: { [key: string]: components$m["schemas"]["ComponentParameter"]; }; _dataResources?: components$m["schemas"]["DataResourceDefinitions"]; /** Indicates this content entry should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$m["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, or not been published yet. * Means nothing for PUTs; it will be ignored */ _patternError?: "NOTFOUND" | "CYCLIC"; /** * Defines patch overrides for the content entry fields. * This can be used to override fields that are defined on patterns. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$m["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's fields may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$m["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the entry. If empty, the current default locale implicitly has data */ _locales?: string[]; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$m["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$m["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$m["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: { /** * Specify one or more entry IDs to fetch. * When `editions=raw`, this matches on edition IDs or entry IDs and edition resolution is disabled. * When `versionId` is passed, this parameter is required and must contain only one entry ID. */ entryIDs: string[]; /** * Specify a historical entry version ID to fetch (retrieved from the entries-history API). * Must be used with the `entryIDs` parameter, and there must be only one entryID passed */ versionId: string; /** Specify a single entry to fetch by slug */ slug: string; /** Filters entry lists by the user who created them. The user is specified by their identity subject */ createdBy: string; /** Max number of records to return */ limit: number; /** Number of records to skip */ offset: number; /** * Sets the sorting of the results. If unspecified, results are sorted by modification date descending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, name_DESC, name_ASC, slug_DESC, slug_ASC */ orderBy: string[]; /** * @deprecated * Returns counts for distinct values of the specified field or fields (provided as comma-separated IDs). */ facetBy: string; /** * Matches entries based on whether they are pattern entries or regular entries. * If true, only pattern entries will be returned. * If false (default), only regular entries will be returned. * If 'any', both pattern and regular entries will be returned (useful for ID lookups). */ pattern: boolean | "any"; /** The project the entry/entries are on */ projectId: string; /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** The content type ID to filter by */ type: string[]; /** * @deprecated * Filters entries lists by the UI status of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ uiStatus: ("Draft" | "Modified" | "Published" | "Orphan")[]; /** Filters entry lists by the user who last updated them. The user is specified by their identity subject */ updatedBy: string; /** * Controls whether the total count of results will be returned along with the current results page in a list. * Has no effect when not fetching a list. This does impact performance when enabled */ withTotalCount: boolean; /** * @deprecated * Returns the UI status string of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ withUIStatus: boolean; /** Returns the definition of any attached workflow along with the entry data */ withWorkflowDefinition: boolean; /** * If true the `_id` unique identifier of blocks will be part of the response data. * If false, the `_id` will not be present in the API response. * Note: the default value depends on the `format`: true for editor or canonical, false for delivery or when no format is specified. * Prefer selecting a `format` rather than using this option. */ withComponentIDs: boolean; /** Performs keyword search on the entries */ keyword: string; /** * If true, any pattern references in the composition will be left unresolved. * This is appropriate if you intend to serialize the composition without patterns * embedded into it, and serialize the pattern data separately. * Default: true when `format` is canonical. False otherwise * Prefer selecting a `format` rather than using this option. */ skipPatternResolution: boolean; /** * @deprecated * This parameter is unused and has no effect. Passing this parameter will become an error in the future */ skipParameterResolution: boolean; /** * If true, any pattern override data is not resolved by the API. * This is intended for internal use in the Canvas editor, and should not be used. * Passing this parameter automatically implies withComponentIDs to be true. * Default: true when `format` is canonical or editor. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipOverridesResolution: boolean; /** * Improves performance by skipping dynamic data revalidations; appropriate for content delivery. * Default: true when `format` is delivery. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipContentTypeResolution: boolean; /** * One or more locales to filter and localize by. * Only entries that enable one of the specified locales _or enable no locales_ will be returned. * The response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned */ locale: string; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId: string; /** * Search on textual fields of an entry. * Matches against fully rendered content including resolved pattern content. * Use this for "where does this content appear" queries. * Note: For long text fields, the tail of the text is not guaranteed to be searchable. * Example: ?search=hello */ search: string; /** * @deprecated * BETA: Semantic search using vector similarity to find content by meaning. * Matches against source content only - pattern base content matches the pattern itself, not consumers. * Use this for "where is this content defined" queries. * Requires AI credits. */ searchSemantic: string; /** * Controls the edition resolution behavior. * * auto: (default) Editions are evaluated automatically and the best matching edition is returned. * When a locale is provided, the edition with the highest priority that enables that locale matches * Without a locale, the default edition is matched * * all: Every edition is returned as a separate row. * * raw: the entryIDs parameter targets exact edition/entry IDs and no edition resolution is performed. * entryIDs MUST be provided with this option. * If versionId is passed, this is always enabled. */ editions: "auto" | "all" | "raw"; /** * Specify a format you want the results in. Any explicit shaping flag (skipPatternResolution, * skipOverridesResolution, withComponentIDs, skipContentTypeResolution) overrides this alias. * - `canonical`: PUT-safe structure — patterns and overrides left * unresolved and component `_id`s included. This is the format the Uniform CLI uses when syncing. * (skipPatternResolution=true, skipOverridesResolution=true, * withComponentIDs=true, skipContentTypeResolution=false). * - `editor`: For loading into a Uniform editor - same as canonical, but with patterns expanded (skipPatternResolution=false). Still PUT-safe — the PUT ignores * the expanded pattern nodes. * - `delivery`: default structure for serving to a frontend — patterns and overrides resolved, * component `_id`s removed, and each entry returned as stored * (skipContentTypeResolution=true). */ format: "canonical" | "editor" | "delivery"; /** * Controls filtering of trashed items. * * exclude: (default) Only return items not in trash. * only: Only return trashed items (for trash view). * include: Return both trashed and non-trashed items. */ deleted: "exclude" | "only" | "include"; }; requestBodies: never; headers: never; pathItems: never; } interface paths$j { "/api/v1/entries-history": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { /** Specify the entry ID to get history for */ entryId: string; /** * @deprecated * The edition ID. When set, gets history for a child edition of the entryId. */ editionId?: string; /** The project the entries(s) are on. */ projectId: string; /** If a request returns a cursor, pass it in this query parameter to get the next page of results. */ cursor?: string; /** The release ID to get history for. Note that release history is independent of base histories. */ releaseId?: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": components$l["schemas"]["HistoryApiResponse"]; }; }; 400: components$l["responses"]["BadRequestError"]; 401: components$l["responses"]["UnauthorizedError"]; 403: components$l["responses"]["ForbiddenError"]; /** Entry not found */ 404: { headers: { [name: string]: unknown; }; content: { "text/plain": string; }; }; 429: components$l["responses"]["RateLimitError"]; 500: components$l["responses"]["InternalServerError"]; }; }; put?: never; post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$l { schemas: { HistoryEntry: { /** The version ID of the entity. This can be used to fetch the version's data via the entity API */ versionId: string; /** The timestamp when the version was created in epoch milliseconds */ timestamp: number; /** The name (full name) of the user who created the version, or "Unknown user" if the author can no longer be resolved */ authorName: string; authorIsApiKey: boolean; /** The identity who created the version; absent on old history entries. */ authorSubject?: string; /** The state of the entity when the history entry was made */ state: number; }; HistoryApiResponse: { /** * If there are more results, this will be populated with a token to pass in the next request to get the next page of results. * If this is undefined then no more results are available */ cursor?: string; /** If more history is available than your plan allows, and additional entries are available by upgrading, this will be true */ truncated?: boolean; /** Version history entries */ results?: components$l["schemas"]["HistoryEntry"][]; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$l["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$l["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$l["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } type HistoryApi$1 = paths$j['/api/v1/entries-history']; type ContentType = components$q['schemas']['ContentType']; type ContentTypePreviewConfiguration = components$q['schemas']['ContentTypePreviewConfiguration']; type ContentTypeField = Exclude[number]; type GetContentTypesOptions = paths$l['/api/v1/content-types']['get']['parameters']['query']; type DeleteContentTypeOptions = paths$l['/api/v1/content-types']['delete']['requestBody']['content']['application/json']; type PutContentTypeBody = paths$l['/api/v1/content-types']['put']['requestBody']['content']['application/json']; type GetContentTypesResponse = paths$l['/api/v1/content-types']['get']['responses']['200']['content']['application/json']; type Entry = components$o['schemas']['EntryApiResponse']; type EntryList = components$o['schemas']['EntryListResponse']; type EntryData = Entry['entry']; type GetEntriesOptions = paths$k['/api/v1/entries']['get']['parameters']['query']; type GetEntriesResponse = paths$k['/api/v1/entries']['get']['responses']['200']['content']['application/json']; type DeleteEntryOptions = paths$k['/api/v1/entries']['delete']['requestBody']['content']['application/json']; type PutEntryBody = paths$k['/api/v1/entries']['put']['requestBody']['content']['application/json']; /** The GET response from /api/v1/entries-history (history for one entry) */ type EntriesHistoryGetParameters = HistoryApi$1['get']['parameters']['query']; /** The GET response from /api/v1/entries-history */ type EntriesHistoryGetResponse = components$q['schemas']['HistoryApiResponse']; interface paths$i { "/api/v1/data-source": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { dataSourceId: string; projectId: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { result: components$k["schemas"]["DataSource"]; }; }; }; 400: components$k["responses"]["BadRequestError"]; 401: components$k["responses"]["UnauthorizedError"]; 403: components$k["responses"]["ForbiddenError"]; 429: components$k["responses"]["RateLimitError"]; 500: components$k["responses"]["InternalServerError"]; }; }; put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { data: components$k["schemas"]["DataSource"]; /** Format: uuid */ projectId: string; /** * Format: uuid * @deprecated * Do not use. May be removed in future */ integrationId?: string; /** The integration type that the data source is attached to. Must be installed in the project */ integrationType?: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$k["responses"]["BadRequestError"]; 401: components$k["responses"]["UnauthorizedError"]; 403: components$k["responses"]["ForbiddenError"]; 429: components$k["responses"]["RateLimitError"]; 500: components$k["responses"]["InternalServerError"]; }; }; post?: never; delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { dataSourceId: string; /** Format: uuid */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$k["responses"]["BadRequestError"]; 401: components$k["responses"]["UnauthorizedError"]; 403: components$k["responses"]["ForbiddenError"]; 429: components$k["responses"]["RateLimitError"]; 500: components$k["responses"]["InternalServerError"]; }; }; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$k { schemas: { /** Defines the shape of a data variable on a Data Source or Data Type */ DataVariableDefinition: { /** Display name of the data variable */ displayName?: string; /** Explanatory text that is provided to the data resource editor to explain what this variable does */ helpText?: string; /** * Type of the data variable. Optionally used as a point of reference for custom integrations to decide how to render an editor for a variable * @defaultValue text */ type?: string; /** Default value of the data variable */ default: string; /** Sets the order of the variable when displayed in a list with other variables. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; /** * An optional arbitrary human readable source identifier to describe where this variable is from. * Some user interfaces may group variables by source value, for example 'From URL' or 'My Integration' */ source?: string; }; /** Additional set of headers, parameters, variables, etc to be used for data resolving in the context like e.g. Unpublished Data. */ AlternativeDataSourceData: { /** Base resource URL of the data source. No trailing slash */ baseUrl: string; /** HTTP headers to pass with requests to the data source */ headers?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Variables needed to make calls to the data source */ variables?: { [key: string]: components$k["schemas"]["DataVariableDefinition"]; }; }; /** * An instance of a data source (i.e. "Master environment of the stable space", "Yelp API", "Sanity dev dataset"). * These are created in the UI and shared across a whole project. * NOTE: If you acquire a list of data sources or do not have manage permissions, you will receive "SECRET" * for all header, parameter, and variable values to obscure the actual encrypted secret value */ DataSource: { /** Public ID of the data source */ id: string; /** Display name of the data source */ displayName: string; /** The type of data connector this connects to (e.g. 'cms-items', provided by an installed integration) */ connectorType: string; /** Base resource URL of the data source. No trailing slash */ baseUrl: string; /** HTTP headers to pass with requests to the data source */ headers?: { key: string; value: string; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; }[]; /** Variables needed to make calls to the data source */ variables?: { [key: string]: components$k["schemas"]["DataVariableDefinition"]; }; /** * Mapping of locale codes to data source locale codes. Keys are Uniform locale codes, values are data source locale codes. * If a locale is not mapped, it will be passed through to the data source as-is */ localeMapping?: { [key: string]: string; }; /** * If true, data source will require additional credentials to access unpublished data. * If false, no additional data source credentials are required and data resources of this data source won't be able to access unpublished data. */ enableUnpublishedMode?: boolean; /** Custom configuration accessible to all data connector UIs (data source, data type, and data resource editors) and custom edgehancers. This data should not contain secrets */ customPublic?: { [key: string]: unknown; }; /** Custom configuration accessible to the data source editor UI and custom edgehancer that may contain secrets. This cannot be read by the data type or data resource editors */ custom?: { [key: string]: unknown; }; /** Different connector detail variants to use in the different contexts like e.g. Unpublished Data */ variants?: { unpublished?: components$k["schemas"]["AlternativeDataSourceData"]; }; /** Created date of the data source in ISO 8601 format (ignored for writes) */ created?: string; /** Last modified date of the data source in ISO 8601 format (ignored for writes) */ modified?: string; /** User or API key ID that created the data source (ignored for writes) */ createdBy?: string; /** User or API key ID that last modified the data source (ignored for writes) */ modifiedBy?: string; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$k["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$k["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$k["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } interface paths$h { "/api/v1/data-sources": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { projectId: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** * Gets a list of data sources. * Note that all parameters, headers, and variables will have the value 'SECRET', as this endpoint * requires minimal permissions. To decrypt secrets, you must be an admin or manage-data-sources privileged * user, and fetch using the `data-source` endpoint for each data source */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { results: components$j["schemas"]["DataSource"][]; }; }; }; 400: components$j["responses"]["BadRequestError"]; 401: components$j["responses"]["UnauthorizedError"]; 403: components$j["responses"]["ForbiddenError"]; 429: components$j["responses"]["RateLimitError"]; 500: components$j["responses"]["InternalServerError"]; }; }; put?: never; post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$j { schemas: { /** Defines the shape of a data variable on a Data Source or Data Type */ DataVariableDefinition: { /** Display name of the data variable */ displayName?: string; /** Explanatory text that is provided to the data resource editor to explain what this variable does */ helpText?: string; /** * Type of the data variable. Optionally used as a point of reference for custom integrations to decide how to render an editor for a variable * @defaultValue text */ type?: string; /** Default value of the data variable */ default: string; /** Sets the order of the variable when displayed in a list with other variables. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; /** * An optional arbitrary human readable source identifier to describe where this variable is from. * Some user interfaces may group variables by source value, for example 'From URL' or 'My Integration' */ source?: string; }; /** Additional set of headers, parameters, variables, etc to be used for data resolving in the context like e.g. Unpublished Data. */ AlternativeDataSourceData: { /** Base resource URL of the data source. No trailing slash */ baseUrl: string; /** HTTP headers to pass with requests to the data source */ headers?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Variables needed to make calls to the data source */ variables?: { [key: string]: components$j["schemas"]["DataVariableDefinition"]; }; }; /** * An instance of a data source (i.e. "Master environment of the stable space", "Yelp API", "Sanity dev dataset"). * These are created in the UI and shared across a whole project. * NOTE: If you acquire a list of data sources or do not have manage permissions, you will receive "SECRET" * for all header, parameter, and variable values to obscure the actual encrypted secret value */ DataSource: { /** Public ID of the data source */ id: string; /** Display name of the data source */ displayName: string; /** The type of data connector this connects to (e.g. 'cms-items', provided by an installed integration) */ connectorType: string; /** Base resource URL of the data source. No trailing slash */ baseUrl: string; /** HTTP headers to pass with requests to the data source */ headers?: { key: string; value: string; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; }[]; /** Variables needed to make calls to the data source */ variables?: { [key: string]: components$j["schemas"]["DataVariableDefinition"]; }; /** * Mapping of locale codes to data source locale codes. Keys are Uniform locale codes, values are data source locale codes. * If a locale is not mapped, it will be passed through to the data source as-is */ localeMapping?: { [key: string]: string; }; /** * If true, data source will require additional credentials to access unpublished data. * If false, no additional data source credentials are required and data resources of this data source won't be able to access unpublished data. */ enableUnpublishedMode?: boolean; /** Custom configuration accessible to all data connector UIs (data source, data type, and data resource editors) and custom edgehancers. This data should not contain secrets */ customPublic?: { [key: string]: unknown; }; /** Custom configuration accessible to the data source editor UI and custom edgehancer that may contain secrets. This cannot be read by the data type or data resource editors */ custom?: { [key: string]: unknown; }; /** Different connector detail variants to use in the different contexts like e.g. Unpublished Data */ variants?: { unpublished?: components$j["schemas"]["AlternativeDataSourceData"]; }; /** Created date of the data source in ISO 8601 format (ignored for writes) */ created?: string; /** Last modified date of the data source in ISO 8601 format (ignored for writes) */ modified?: string; /** User or API key ID that created the data source (ignored for writes) */ createdBy?: string; /** User or API key ID that last modified the data source (ignored for writes) */ modifiedBy?: string; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$j["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$j["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$j["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } interface paths$g { "/api/v1/data-types": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { projectId: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { results: components$i["schemas"]["DataType"][]; }; }; }; 400: components$i["responses"]["BadRequestError"]; 401: components$i["responses"]["UnauthorizedError"]; 403: components$i["responses"]["ForbiddenError"]; 429: components$i["responses"]["RateLimitError"]; 500: components$i["responses"]["InternalServerError"]; }; }; put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { data: components$i["schemas"]["DataType"]; /** Format: uuid */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$i["responses"]["BadRequestError"]; 401: components$i["responses"]["UnauthorizedError"]; 403: components$i["responses"]["ForbiddenError"]; 429: components$i["responses"]["RateLimitError"]; 500: components$i["responses"]["InternalServerError"]; }; }; post?: never; delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { typeId: string; /** Format: uuid */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$i["responses"]["BadRequestError"]; 401: components$i["responses"]["UnauthorizedError"]; 403: components$i["responses"]["ForbiddenError"]; 429: components$i["responses"]["RateLimitError"]; 500: components$i["responses"]["InternalServerError"]; }; }; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$i { schemas: { /** Defines the shape of a data variable on a Data Source or Data Type */ DataVariableDefinition: { /** Display name of the data variable */ displayName?: string; /** Explanatory text that is provided to the data resource editor to explain what this variable does */ helpText?: string; /** * Type of the data variable. Optionally used as a point of reference for custom integrations to decide how to render an editor for a variable * @defaultValue text */ type?: string; /** Default value of the data variable */ default: string; /** Sets the order of the variable when displayed in a list with other variables. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; /** * An optional arbitrary human readable source identifier to describe where this variable is from. * Some user interfaces may group variables by source value, for example 'From URL' or 'My Integration' */ source?: string; }; /** A specific type of data that a Data Source can provide (i.e. "Recipe", "Recipes List by Tag", "Yelp Reviews of My Restaurant"). These are created in the UI and shared a whole project */ DataType: { /** Public ID of the data type */ id: string; /** Display name of the data type */ displayName: string; /** Public ID of the associated data source */ dataSourceId: string; /** * A connector-specific archetype for this data type; used to select UI as well as perform any * necessary post-processing on the response. e.g. 'cms-entry', 'cms-query'. Can be undefined if * no special UI or processing is required */ archetype?: string; allowedOnComponents?: string[]; /** Resource path, appended to the data source's baseUrl (e.g. baseUrl = https://base.url, path = /v1/endpoint -> final URL https://base.url/v1/endpoint). Must have a leading slash */ path: string; /** Time-to-live (in seconds) for the resource data cache */ ttl?: number; /** A key for the resource data cache purging */ purgeKey?: string; /** URL to a custom badge icon for the Uniform dashboard for this data type. If not set falls back to the data connector or integration icons */ badgeIconUrl?: string; /** HTTP headers to pass with requests to the data type. Merged with headers from the data source, overriding identical keys */ headers?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Query String parameters to pass with requests to the data type. Merged with parameters from the data source, overriding identical keys */ parameters?: { key: string; value: string; omitIfEmpty?: boolean; }[]; /** Body to pass with requests to the data type (ignored unless the method is POST) */ body?: string; /** * HTTP method to use with requests to the data type * @defaultValue GET */ method: "GET" | "POST" | "HEAD"; /** Variables needed to make calls to the data type. Merged with variables from the data source, overriding identical keys */ variables?: { [key: string]: components$i["schemas"]["DataVariableDefinition"]; }; /** Custom configuration specific to the data source being defined */ custom?: { [key: string]: unknown; }; /** Created date of the data type in ISO 8601 format (ignored for writes) */ created?: string; /** Last modified date of the data type in ISO 8601 format (ignored for writes) */ modified?: string; /** User or API key ID that created the data type (ignored for writes) */ createdBy?: string; /** User or API key ID that last modified the data type (ignored for writes) */ modifiedBy?: string; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$i["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$i["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$i["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } interface paths$f { "/api/v1/prompts": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; /** @deprecated */ get: { parameters: { query: { promptId?: string; projectId: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": components$h["schemas"]["Prompt"] | components$h["schemas"]["Prompt"][]; }; }; 400: components$h["responses"]["BadRequestError"]; 401: components$h["responses"]["UnauthorizedError"]; 403: components$h["responses"]["ForbiddenError"]; 429: components$h["responses"]["RateLimitError"]; 500: components$h["responses"]["InternalServerError"]; }; }; /** @deprecated */ put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { data: components$h["schemas"]["Prompt"]; /** Format: uuid */ projectId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$h["responses"]["BadRequestError"]; 401: components$h["responses"]["UnauthorizedError"]; 403: components$h["responses"]["ForbiddenError"]; 429: components$h["responses"]["RateLimitError"]; 500: components$h["responses"]["InternalServerError"]; }; }; post?: never; /** @deprecated */ delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** Format: uuid */ projectId: string; /** Format: uuid */ promptId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$h["responses"]["BadRequestError"]; 401: components$h["responses"]["UnauthorizedError"]; 403: components$h["responses"]["ForbiddenError"]; 429: components$h["responses"]["RateLimitError"]; 500: components$h["responses"]["InternalServerError"]; }; }; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$h { schemas: { /** AI Prompt definition */ Prompt: { /** * Format: uuid * Unique identifier for the prompt */ id: string; /** Unique identifier for the integration that this prompt belongs to */ integrationType: string; /** Name for the prompt */ name?: string | null; /** Text for the prompt */ text?: string | null; /** Data for the prompt */ data?: { [key: string]: unknown; } | null; /** Turn off/on prompt */ enabled?: boolean | null; /** Integration default prompt */ builtIn?: boolean | null; /** Supported parameter types */ parameterTypes?: string[] | null; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$h["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$h["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$h["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } type PromptsApi = paths$f['/api/v1/prompts']; type DataTypeApi = paths$g['/api/v1/data-types']; type DataSourcesApi = paths$h['/api/v1/data-sources']; type DataSourceApi = paths$i['/api/v1/data-source']; /** Query parameter options for GET /api/v1/data-types */ type DataTypeGetParameters = DataTypeApi['get']['parameters']['query']; /** The GET response from /api/v1/data-types */ type DataTypeGetResponse = DataTypeApi['get']['responses']['200']['content']['application/json']; /** The PUT request body for /api/v1/data-types */ type DataTypePutParameters = DataTypeApi['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/data-types */ type DataTypeDeleteParameters = DataTypeApi['delete']['requestBody']['content']['application/json']; /** Query parameter options for GET /api/v1/data-source */ type DataSourceGetParameters = DataSourceApi['get']['parameters']['query']; /** Query parameter options for GET /api/v1/data-sources */ type DataSourcesGetParameters = DataSourcesApi['get']['parameters']['query']; /** The GET response from /api/v1/data-sources */ type DataSourceGetResponse = DataSourceApi['get']['responses']['200']['content']['application/json']; /** The GET response from /api/v1/data-sources */ type DataSourcesGetResponse = DataSourcesApi['get']['responses']['200']['content']['application/json']; /** The PUT request body for /api/v1/data-source */ type DataSourcePutParameters = DataSourceApi['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/data-source */ type DataSourceDeleteParameters = DataSourceApi['delete']['requestBody']['content']['application/json']; /** Query parameter options for GET /api/v1/prompts */ type PromptsGetParameters = PromptsApi['get']['parameters']['query']; /** The GET response from /api/v1/prompts */ type PromptsGetResponse = PromptsApi['get']['responses']['200']['content']['application/json']; /** The PUT request body for /api/v1/prompts */ type PromptsPutParameters = PromptsApi['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/prompts */ type PromptsDeleteParameters = PromptsApi['delete']['requestBody']['content']['application/json']; type DataType = components$q['schemas']['DataType']; type DataSource = components$q['schemas']['DataSource']; type DataVariableDefinition = components$q['schemas']['DataVariableDefinition']; type Prompt = components$q['schemas']['Prompt']; type DataSourceVariantsKeys = keyof NonNullable; type DataSourceVariantData = NonNullable['unpublished']; interface paths$e { "/api/v1/labels": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; /** Gets labels for a project */ get: { parameters: { query: { /** The project ID to get labels for */ projectId: string; /** Number of records to skip */ offset?: number | null; /** Maximum number of records to return */ limit?: number; /** Comma-separated list of label public IDs */ labelIds?: string; /** Public ID of the parent group label */ groupId?: string; /** Filter to only group labels */ isGroup?: boolean | null; /** Filter labels with public ID prefix */ idPrefix?: string; /** Filter labels with display name prefix (case insensitive) */ namePrefix?: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { labels: { projectId: string; label: { /** Public ID of the label (cannot be changed after creation) */ publicId: string; /** Human readable name of the label */ displayName: string; /** Whether this label is a group label (cannot be changed after creation) */ isGroup: boolean; /** Public ID of the parent group label */ parent?: string; /** Human readable color identifier */ color: string; /** Short description of what the label is about */ description?: string; /** Scope of the label (currently unused) */ scope: string[]; }; /** Format: date-time */ created: string; /** Format: date-time */ modified: string; createdBy?: string; modifiedBy?: string; }[]; totalCount: number; }; }; }; 400: components$g["responses"]["BadRequestError"]; 401: components$g["responses"]["UnauthorizedError"]; 403: components$g["responses"]["ForbiddenError"]; 429: components$g["responses"]["RateLimitError"]; 500: components$g["responses"]["InternalServerError"]; }; }; /** Creates or updates a label */ put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { projectId: string; label: { /** Public ID of the label */ publicId: string; displayName: string; /** @defaultValue false */ isGroup?: boolean; parent?: string; color: string; description?: string; /** Ignored on PUT */ scope?: string[]; }; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content: { "application/json": string; }; }; 400: components$g["responses"]["BadRequestError"]; 401: components$g["responses"]["UnauthorizedError"]; 403: components$g["responses"]["ForbiddenError"]; 429: components$g["responses"]["RateLimitError"]; 500: components$g["responses"]["InternalServerError"]; }; }; post?: never; /** Deletes a label */ delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** The project ID */ projectId: string; /** Public ID of the label to delete */ labelId: string; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content: { "application/json": string; }; }; 400: components$g["responses"]["BadRequestError"]; 401: components$g["responses"]["UnauthorizedError"]; 403: components$g["responses"]["ForbiddenError"]; 429: components$g["responses"]["RateLimitError"]; 500: components$g["responses"]["InternalServerError"]; }; }; /** Handles preflight requests. This endpoint allows CORS. */ options: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** ok */ 204: { headers: { [name: string]: unknown; }; content?: never; }; }; }; head?: never; patch?: never; trace?: never; }; } interface components$g { schemas: { Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$g["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$g["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$g["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } type LabelsApi = paths$e['/api/v1/labels']; type LabelsQuery = LabelsApi['get']['parameters']['query']; type LabelPut = LabelsApi['put']['requestBody']['content']['application/json']; type LabelDelete = LabelsApi['delete']['requestBody']['content']['application/json']; type LabelsResponse = LabelsApi['get']['responses']['200']['content']['application/json']; type Label = LabelsResponse['labels'][number]; interface paths$d { "/api/v1/locales": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { projectId: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** Gets a list of all defined locales for a project */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": { results: components$f["schemas"]["Locale"][]; }; }; }; 400: components$f["responses"]["BadRequestError"]; 401: components$f["responses"]["UnauthorizedError"]; 403: components$f["responses"]["ForbiddenError"]; 429: components$f["responses"]["RateLimitError"]; 500: components$f["responses"]["InternalServerError"]; }; }; put: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": components$f["schemas"]["LocalePutBody"]; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$f["responses"]["BadRequestError"]; 401: components$f["responses"]["UnauthorizedError"]; 403: components$f["responses"]["ForbiddenError"]; 429: components$f["responses"]["RateLimitError"]; 500: components$f["responses"]["InternalServerError"]; }; }; post?: never; delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": components$f["schemas"]["LocaleDeleteBody"]; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$f["responses"]["BadRequestError"]; 401: components$f["responses"]["UnauthorizedError"]; 403: components$f["responses"]["ForbiddenError"]; 429: components$f["responses"]["RateLimitError"]; 500: components$f["responses"]["InternalServerError"]; }; }; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$f { schemas: { Locale: { /** * The locale code * @example en-US */ locale: string; /** * The locale's display name in the UI * @example English (United States) */ displayName: string; /** * Whether this is the default locale * @example true */ isDefault?: boolean; /** * Primary grouping to place the locale in, i.e. region or other business-specific grouping type. * When not set, the locale is not placed in any grouping. * Used only for display purposes. * @example EMEA, Belgium, North America, etc. */ group?: string; /** * Arbitrary tags to associate with the locale. Used to create locale selection presets. * @example [ * "all-english", * "english-emea", * "core" * ] */ tags?: string[]; /** * Order in which the locale should be displayed in the UI. * Lower numbers are displayed first. */ order?: number; }; LocalePutBody: { locale: components$f["schemas"]["Locale"]; /** * Format: uuid * The project ID */ projectId: string; }; LocaleDeleteBody: { locale: string; /** * Format: uuid * The project ID */ projectId: string; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$f["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$f["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$f["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } type LocalesApi = paths$d['/api/v1/locales']; /** A locale definition */ type Locale = components$f['schemas']['Locale']; /** Query parameter options for GET /api/v1/locales */ type LocalesGetParameters = LocalesApi['get']['parameters']['query']; /** The GET response from /api/v1/locales */ type LocalesGetResponse = LocalesApi['get']['responses']['200']['content']['application/json']; /** The PUT request body for /api/v1/locales */ type LocalePutParameters = LocalesApi['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/locales */ type LocaleDeleteParameters = LocalesApi['delete']['requestBody']['content']['application/json']; declare const LOCALE_DYNAMIC_INPUT_NAME = "locale"; interface components$e { schemas: { RouteResponse: components$e["schemas"]["RouteResponseRedirect"] | components$e["schemas"]["RouteResponseComposition"] | components$e["schemas"]["RouteResponseNotFound"]; /** The route matches a redirection configured in Uniform */ RouteResponseRedirect: { /** The route that was matched in the redirects */ matchedRoute: string; dynamicInputs?: components$e["schemas"]["RouteDynamicInputs"]; /** @enum {string} */ type: "redirect"; redirect: components$e["schemas"]["Redirect"]; }; /** * The route matches a composition. * If any dynamic segments or query parameters are present in the route, they will be returned as dynamic inputs in the response */ RouteResponseComposition: { /** The route that was matched in the project map */ matchedRoute: string; dynamicInputs?: components$e["schemas"]["RouteDynamicInputs"]; /** * Indicates the data variant that was fetched for data resources. * undefined: Data resources were resolved using published data from their data source * unpublished: Data resources which support unpublished data retrieved unpublished data from their data source. Data resources that did not support unpublished data retrieved published data instead. */ dataResourcesVariant?: "unpublished"; /** @enum {string} */ type: "composition"; compositionApiResponse: components$e["schemas"]["CompositionApiResponse"]; }; /** * The route does not match any configured redirections or compositions. * NOTE: This response differs from a HTTP 404, which indicates that the project map or project ID was not found. * Receiving this response with HTTP 200 means that the project was found, but the route did not match anything */ RouteResponseNotFound: { /** @enum {string} */ type: "notFound"; }; RouteDynamicInputs: { [key: string]: string; }; Redirect: { /** * Format: uuid * Id of the redirect */ id?: string; /** Source meant to match a url that needs to be redirected */ sourceUrl: string; /** Target meant to be redirected to */ targetUrl: string; /** Redirect type to occur from this redirect */ targetStatusCode: number; /** * Format: uuid * Project map node related to the source this redirect */ sourceProjectMapNodeId?: string; /** * Format: uuid * Project map node related to the target this redirect */ targetProjectMapNodeId?: string; /** * Format: uuid * Project map related to this redirect */ projectMapId?: string; /** Signals the redirect engine to retain query string parameters to the target url */ sourceRetainQuerystring?: boolean; /** Incoming requests must match the domain that's defined in the redirection source */ sourceMustMatchDomain?: boolean; /** Rewritten url should match the protocol (http / https) of the incoming request instead of whatever is defined in the redirection target */ targetPreserveIncomingProtocol?: boolean; /** Rewritten url should match the domain of the incoming request regardless of what is defined in the redirection target */ targetPreserveIncomingDomain?: boolean; /** Merge incoming querystring with the querystring defined on the redirection target, taking the incoming querystring parameter where a merge is not possible */ targetMergeQuerystring?: boolean; /** Label as system generated or user generated */ labelAsSystem?: boolean; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$e["schemas"]["VisibilityCriteria"] | components$e["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$e["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$e["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$e["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$e["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$e["schemas"]["ComponentParameterConditions"]; }; }; ProjectMapNodeAllowedQueryString: { /** The name of the query string parameter */ name: string; /** The default value of the query string if it is not provided by an incoming route path */ value?: string; /** Help text for authors who might be setting up a preview value for this query string */ helpText?: string; /** * Controls whether a global query string is always shown in Canvas or must be opted into. * This property is ignored on node-level query strings. When omitted, the query string is always shown. */ editorVisibility?: "opt-in"; /** Configuration for providing a list of allowed values for this query string */ optionsSource?: { /** * The source type for the options */ source: "static"; options: { /** Display name for the option */ name: string; /** The actual value to be used */ value: string; }[]; }; }; ProjectMapNodeData: { /** While performing a search if a node is a hit, this property will return true. If it's supporting structure, like a parent of a search hit, it will return false */ isSearchHit?: boolean; /** Query strings that are allowed to be passed to the node */ queryStrings?: components$e["schemas"]["ProjectMapNodeAllowedQueryString"][]; /** * For dynamic nodes, this is the preview value for the dynamic value. * The preview value is used when editing a connected composition, and is the default * dynamic node value unless the author has explicitly chosen a different value */ previewValue?: string; }; /** Project map node information related to a component */ CompositionProjectMapNodeInfo: { /** * Format: uuid * Unique identifier for the project map node */ id: string; /** * Fallback path of the project map node. * Note that the node may have matched via a locale-specific path which is in the `locales` object */ path: string; /** * Format: uuid * Unique identifier for the project map that this node belongs to */ projectMapId: string; data?: components$e["schemas"]["ProjectMapNodeData"]; /** * Locale-specific paths of the project map node. * Keys are locale codes */ locales?: { [key: string]: { /** Locale-specific path of the project map node */ path: string; /** Whether the path is inherited from a parent node which defined a path segment in this locale */ inherited: boolean; }; }; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$e["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$e["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$e["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$e["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$e["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$e["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$e["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$e["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$e["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$e["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$e["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$e["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$e["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$e["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** Defines the shape of the root component in a composition */ RootComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$e["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Project map nodes associated with this component. Must pass withProjectMapNodes parameter to be populated */ projectMapNodes?: components$e["schemas"]["CompositionProjectMapNodeInfo"][]; /** Slots containing any child components */ slots?: { [key: string]: components$e["schemas"]["ComponentInstance"][]; }; /** The ID of the composition */ _id: string; /** Slug pattern of this component */ _slug?: string | null; /** Friendly name of this component */ _name: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$e["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _dataResources?: components$e["schemas"]["DataResourceDefinitions"]; _patternError?: components$e["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$e["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$e["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$e["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the composition. If empty, the current default locale implicitly has data */ _locales?: string[]; /** * Names of opt-in global query strings surfaced in the Canvas editor for this composition or pattern. * Opt-ins coming from a resolved pattern move to _patternOptedInQueryStrings, so this always * holds only what was authored here. Omitted whenever overrides are resolved. */ _optedInQueryStrings?: string[]; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$e["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$e["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$e["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$e["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; CompositionApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Present only when `withUIStatus` is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown"; /** * Format: uuid * The project ID this composition is part of */ projectId: string; /** * Format: date-time * Created date string for this composition */ created: string; /** * Format: date-time * Modified date string for this composition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** User name of the creator of this composition */ creator?: string; /** User name of the last editor of this composition */ author?: string; /** * Format: uuid * Reference to the category this component definition belongs to */ categoryId?: string; /** A description of the component definition */ description?: string; /** A preview image URL of the component definition */ previewImageUrl?: string; /** Indicates if the composition is a pattern that can be referenced in other compositions */ pattern: boolean; /** * If the instance is a pattern, this indicates if it's a component pattern or a composition pattern */ patternType?: "component" | "composition"; /** * Format: uuid * The release this composition belongs to. If not set, it belongs to the base */ releaseId?: string; composition: components$e["schemas"]["RootComponentInstance"]; /** * Format: uuid * The workflow ID assigned to this composition, if any. Normally comes from the component definition */ workflowId?: string; /** * Format: uuid * The stage ID the composition is in within its assigned workflow. If undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Returned only when `withWorkflowDefinition` is true */ workflowDefinition?: components$e["schemas"]["WorkflowDefinition"]; /** * Format: uuid * The edition ID. When set, this is a child edition of the composition in _id. */ editionId?: string; /** * The name of the composition or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or composition. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; }; responses: never; parameters: { /** The project to fetch a route from */ projectId: string; /** * The path to resolve. Dynamic project map nodes and redirects can be resolved when a matching path is passed. * Query string parameters may be passed with the path. They are ignored for route matching. * If the route matches a composition and the project map node allows passed query string parameters, query parameters will * be returned as as dynamic inputs to the composition. * * Examples: * * route "/company/about-us" would match "/company/about-us" in project map or redirects * * route "/products/123" would match "/products/:productId" in project map or "/products/*" in redirects * * route "/products/123?color=red" would match "/products/:productId" in project map, and provde productId=123 and color=red as dynamic inputs to the composition * * Conflict resolution: * If a route matches multiple possible project map or redirect nodes, the resulting action will use the following logic: * * If a redirect matches, it wins over project map nodes in all cases * * If multiple redirects or project map nodes match the route, the one with the most specific path wins: * * The route with the most path segments wins * * If several matches have the same number of segments, the one with the fewest dynamic segments wins * * If still ambiguous, the first matching route arbitrarily wins */ path: string; /** Specify a project map ID to fetch route from. If not specified, the default project map for the projectId is used */ projectMapId: string; /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * If true the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response */ withComponentIDs: boolean; /** * @deprecated * Has no effect. */ withContentSourceMap: boolean; /** * One or more locales to localize the response to. * When the result is a composition, it includes only the first matching locale's data. * If no matching locale is found, the response will be a not-found result. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed: * - If a dynamic :locale path segment is defined on a project map ancestor node, then it will be used as the locale. If the path segment and this parameter are provided, the parameter takes precedence. * - Otherwise, all locales' data is returned. * * When the result is a redirect, this parameter has no effect */ locale: string; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId: string; /** * Indicates the data variant that was fetched for data resources. * undefined: Data resources were resolved using published data from their data source * unpublished: Data resources which support unpublished data retrieved unpublished data from their data source. Data resources that did not support unpublished data retrieved published data instead. */ dataSourceVariant: "unpublished"; /** * When true, redirects are not evaluated for the route matching; the result will be either a composition or not found. * Note: this is always true when state=63 (internal RSC editor state) to allow contextual editing of compositions * that have redirects configured on their paths. */ ignoreRedirects: boolean; }; requestBodies: never; headers: never; pathItems: never; } interface paths$c { "/api/v1/canvas": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; /** * In addition to the named parameters below, this endpoint accepts the * following query parameter conventions which are pattern-validated and * therefore not declared as named parameters: * * * `filters.[]` — content filtering (documented below). * * `select.[]` — data projection (documented below). * * #### Content filtering (`filters.*`) * * Filtering narrows list results to compositions matching field values. * The allowed field names are project-specific — they come from the * project's component definitions — which is why `filters.*` parameters * are pattern-validated rather than declared as named parameters. * * Syntax: `filters.[]=`. `` is one of: * * * A system field: `name`, `slug`, `type`, `created`, `modified`, * `entityId`, `editionId`, `releaseId`, `patternId`, `creator`, * `creatorSubject`, `author`, `authorSubject`, `projectMapId`, * `projectMapNodeId`, `workflowId`, `workflowStageId`, `categoryId`, * `labels`, `labelGroups`, `uiStatus`, or `locale`. * * A component parameter, addressed as `parameters.`. * Filtering by parameters requires also filtering to a single * composition type (e.g. `filters.type[eq]=...`). * * A sub-property of a parameter for certain parameter types: * content references (`parameters..slug|name|type`), links * (`parameters..type|projectMapNodeId`), and assets * (`parameters..url|title|description|mediaType`). * * | Operator | Effect | * |---|---| * | `[eq]` / `[neq]` | Exact equality / inequality. | * | `[match]` | Contains (text search) match; text-like fields only. | * | `[starts]` | Prefix match. Value limited to letters, numbers, `_`, `.`, `-`, and spaces. | * | `[lt]` / `[lte]` / `[gt]` / `[gte]` | Comparisons for number, date, and datetime fields (including `created` / `modified`). | * | `[in]` / `[nin]` | Comma-separated list; matches any (OR) / none of the values. | * | `[all]` | Comma-separated list; list-valued fields (e.g. `labels`, multi-selects) must contain every value (AND). | * | `[def]` | `true` or `false`; whether the field has a value at all. | * * Behavior: * * * Values are single strings, or comma-separated lists for `[in]`, * `[nin]`, and `[all]`. Dates accept `YYYY-MM-DD` or a full datetime * string. An empty value is rejected — use `[def]` to test presence. * * Not every operator is valid for every field; the allowed set depends * on the field's type. An unsupported combination returns HTTP 400 * with the supported operators listed. * * Malformed keys, unknown operators, and unknown field names return * HTTP 400. * * Filters match root compositions only. * * Examples: * * * `filters.type[eq]=landingPage` — only compositions of type `landingPage`. * * `filters.modified[gte]=2026-01-01` — modified this year. * * `filters.type[eq]=landingPage&filters.parameters.audience[in]=b2b,b2c` — parameter filter scoped to one type. * * `filters.labels[all]=approved,featured` — has both labels. * * #### Data projection (`select.*`) * * Projection returns a subset of the response by pruning fields (parameters), * field types, and slots before values are resolved. The allowed names are * project-specific — they come from the project's component definitions and * content types — which is why `select.*` parameters are pattern-validated * rather than declared as named parameters. * * Syntax: `select.[]=`. Values are comma-separated * lists of names. `*` is the only wildcard and matches zero or more * characters (e.g. `seo_*`). * * | Parameter | Effect | * |---|---| * | `select.fields[only]=a,b` | Keep only the named fields/parameters; drop everything else. | * | `select.fields[except]=a,b` | Drop the named fields/parameters; keep everything else. | * | `select.fields[locales]=a,b` | For the named fields that survive filtering, return the full per-locale value map instead of only the requested locale's value. | * | `select.fields[blockDepth]=N` | Limit how many levels of block field children are kept. `0` removes all block fields; `preserveAll` prevents projection from trimming fields inside block children. | * | `select.fieldTypes[only]=a,b` | Keep only fields of the named types (type IDs such as `text`, `richText`, `asset`). | * | `select.fieldTypes[except]=a,b` | Drop fields of the named types. | * | `select.slots[only]=a,b` | Keep only the named slots. | * | `select.slots[except]=a,b` | Drop the named slots. | * | `select.slots[depth]=N` | Limit how many levels of nested components are kept in slots. | * | `select.slots.[depth]=N` | Depth limit for one specific slot; overrides `slots[depth]`. | * * Behavior: * * * Projection applies recursively at every component and block in the * returned tree, and is forwarded into entries resolved through reference * fields. * * When operators combine, all `[only]` sets are intersected first, then * `[except]` sets are subtracted — exclusion always wins. * * Unknown field, slot, or type names are silent no-ops (the tree shape is * preserved; non-matching content is simply absent). Unknown operators * return HTTP 400. * * An empty list (`select.fields[only]=` or `select.slots[only]=`) strips * every member of that bucket; `[except]=*` is equivalent. * * `[depth]` counts nesting within a single fetched tree and resets inside * referenced entries. * * Examples: * * * `select.fields[only]=title,slug` — keep only titles and slugs, everywhere in the tree. * * `select.fieldTypes[except]=richText` — everything except rich-text fields. * * `select.fields[only]=title&select.slots[only]=` — root title only, with all slots flattened. * * `select.slots[depth]=2&select.fields[only]=label,url` — two levels of nested components, trimmed to `label` and `url`. */ get: { parameters: { query: { /** * Specify a single composition ID to fetch. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters. * When `editions=raw`, this parameter matches on composition or edition IDs and edition resolution is disabled. */ compositionId?: components$d["parameters"]["compositionId"]; /** * Specify a single component ID to fetch the component's composition defaults. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ componentId?: components$d["parameters"]["componentId"]; /** * Specify a historical composition version ID to fetch (retrieved from the canvas-history API). * Must be used with the `compositionId` parameter */ versionId?: components$d["parameters"]["versionId"]; /** * Specify multiple composition IDs to fetch. The response type will be a list. * This is a primary query parameter and cannot be used with any other primary query parameters. * When `editions=raw`, this parameter matches on composition or edition IDs and edition resolution is disabled. */ compositionIDs?: components$d["parameters"]["compositionIDs"]; /** * Filters composition lists by the user who created them. The user is specified by their identity subject. * This is a list query parameter and cannot be used with any primary query parameters */ createdBy?: components$d["parameters"]["createdBy"]; /** * Matches compositions where their name, slug, or definition name contains the specified keyword. * NOT a full-text search; does not match composition contents. * This is a list query parameter and cannot be used with any primary query parameters */ keyword?: components$d["parameters"]["keyword"]; /** * Maximum number of records to return * This is a list query parameter and cannot be used with any primary query parameters */ limit?: components$d["parameters"]["limit"]; /** * Number of records to skip * This is a list query parameter and cannot be used with any primary query parameters */ offset?: components$d["parameters"]["offset"]; /** * Sets the sorting of the results. If unspecified, results are sorted by name ascending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, * name_DESC, name_ASC, slug_DESC, slug_ASC. * When using primary query parameters, this parameter is ignored */ orderBy?: components$d["parameters"]["orderBy"]; /** * @deprecated * Returns counts for distinct values of the specified field or fields (provided as comma-separated IDs). */ facetBy?: components$d["parameters"]["facetBy"]; /** * Matches compositions based on whether they are a pattern composition or a regular composition. * If true, only pattern compositions will be returned. * If false, only regular compositions will be returned. * If omitted or 'any', both pattern and regular compositions will be returned. * This is a list query parameter and cannot be used with any primary query parameters */ pattern?: components$d["parameters"]["pattern"]; /** * This specifies which type of patterns to return. This query parameter has no effect when `pattern` is false. * * `all` - Returns all pattern instances * * `component` - Returns only component patterns * * `composition` - Returns only composition patterns */ patternType?: components$d["parameters"]["patternType"]; /** * @deprecated * Includes the `patternType` attribute in the response */ withPatternType?: components$d["parameters"]["withPatternType"]; /** The project the composition(s) belong to */ projectId: components$d["parameters"]["projectId"]; /** * Specify a project map ID to fetch by path or node ID from. * If not specified, the default project map for the projectId is used. * Only used when fetching by projectMapNodeId or projectMapNodePath */ projectMapId?: components$d["parameters"]["projectMapId"]; /** * Specify a single composition to fetch by associated project map node ID. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ projectMapNodeId?: components$d["parameters"]["projectMapNodeId"]; /** * Specify a single composition to fetch by associated project map node path. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ projectMapNodePath?: components$d["parameters"]["projectMapNodePath"]; /** * @deprecated * Signals an enhancer proxy to skip processing enhancements to the data and return raw data only. * This improves performance if you do not require enhanced component data. * If calling the Canvas API directly with no enhancer proxy, this has no effect */ skipEnhance?: components$d["parameters"]["skipEnhance"]; /** * If true, any pattern references in the composition will be left unresolved. * This is appropriate if you intend to serialize the composition without patterns * embedded into it, and serialize the pattern data separately. * Default: true when `format` is canonical. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipPatternResolution?: components$d["parameters"]["skipPatternResolution"]; /** * @deprecated * This parameter is unused and has no effect. Passing this parameter will become an error in the future */ skipParameterResolution?: components$d["parameters"]["skipParameterResolution"]; /** * If true, any pattern override data is not resolved by the API. * This is intended for internal use in the Canvas editor and should not be used. * Passing this parameter automatically implies `withComponentIDs` is true. * Default: true when `format` is canonical or editor. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipOverridesResolution?: components$d["parameters"]["skipOverridesResolution"]; /** * Specify a single composition to fetch by slug. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ slug?: components$d["parameters"]["slug"]; /** Filtration by category ID. An empty string can be used to include records without a category. */ categories?: components$d["parameters"]["categories"]; /** * Publishing state to fetch. 0 = draft, 64 = published. * This is a list query parameter and cannot be used with any primary query parameters */ state?: components$d["parameters"]["state"]; /** * The component type (by public ID) to filter by. Note that this filters the root composition type only; components in slots are not matched by this filter. * This is a list query parameter and cannot be used with any primary query parameters */ type?: components$d["parameters"]["type"]; /** * @deprecated * Filters composition lists by the UI status of the composition. * This internal status is subject to change without notice and is thus marked deprecated to discourage use of internal data. * This is a list query parameter and cannot be used with any primary query parameters */ uiStatus?: components$d["parameters"]["uiStatus"]; /** * Filters out compositions without attached node or filters out compositions with attached nodes * if set to false. If not specified, no filtration is applied. * This is a list query parameter and cannot be used with any primary query parameters */ attachedToProjectMap?: components$d["parameters"]["attachedToProjectMap"]; /** * Filters composition lists by the user who last updated them. The user is specified by their identity subject. * This is a list query parameter and cannot be used with any primary query parameters */ updatedBy?: components$d["parameters"]["updatedBy"]; /** * If true, the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response. * Note: the default value depends on the `format`: true for editor or canonical, false for delivery or when no format is specified. * Prefer selecting a `format` rather than using this option. */ withComponentIDs?: components$d["parameters"]["withComponentIDs"]; /** * Controls whether the total count of results will be returned along with the current results page in a list. * Has no effect when not fetching a list. This does impact performance when enabled */ withTotalCount?: components$d["parameters"]["withTotalCount"]; /** * @deprecated * Returns the UI status string of the composition. * This internal status is subject to change without notice and is thus marked deprecated to discourage use of internal data */ withUIStatus?: components$d["parameters"]["withUIStatus"]; /** Returns the definition of any attached workflow along with the composition data */ withWorkflowDefinition?: components$d["parameters"]["withWorkflowDefinition"]; /** Includes project map node information in the composition results */ withProjectMapNodes?: components$d["parameters"]["withProjectMapNodes"]; /** * @deprecated * Has no effect. */ withContentSourceMap?: components$d["parameters"]["withContentSourceMap"]; /** * One or more locales to filter and localize by. * For list responses, only compositions that enable one of the specified locales _or enable no locales_ will be returned. When more than one locale is passed, the list matches with an OR on each locale. * For all types of response, the response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned. * If a composition is requested by ID and does not possess any of the specified locales, HTTP 404 will be returned */ locale?: components$d["parameters"]["locale"]; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId?: components$d["parameters"]["releaseId"]; /** * Search on textual fields of a composition. * Matches against fully rendered content including resolved pattern content. * Use this for "where does this content appear" queries. * Note: For long text fields, the tail of the text is not guaranteed to be searchable. * Example: ?search=hello */ search?: components$d["parameters"]["search"]; /** * @deprecated * BETA: Semantic search using vector similarity to find content by meaning. * Matches against source content only - pattern base content matches the pattern itself, not consumers. * Use this for "where is this content defined" queries. * Requires AI credits. */ searchSemantic?: components$d["parameters"]["searchSemantic"]; /** * Controls the edition resolution behavior. * * auto: (default) Editions are evaluated automatically and the best matching edition is returned. * When a locale is provided, the edition with the highest priority that enables that locale matches * Without a locale, the default edition is matched * * all: Every edition is returned as a separate row. * Note: this has no effect when used with compositionId which always returns a single result. * * raw: the compositionId and compositionIDs parameters target exact edition/composition IDs and no edition resolution is performed. * compositionId or compositionIDs MUST be provided with this option. * If versionId is passed, this is always enabled. */ editions?: components$d["parameters"]["editions"]; /** * Specify a format you want the results in. Any explicit shaping flag (skipPatternResolution, * skipOverridesResolution, withComponentIDs) overrides this alias. * - `canonical`: PUT-safe structure — patterns and overrides left * unresolved and component `_id`s included. This is the format the Uniform CLI uses when syncing. * (skipPatternResolution=true, skipOverridesResolution=true, * withComponentIDs=true). * - `editor`: For loading into a Uniform editor - same as canonical, but with patterns expanded (skipPatternResolution=false). Still PUT-safe — the PUT ignores * the expanded pattern nodes. * - `delivery`: default structure for serving to a frontend — patterns and overrides resolved * and component `_id`s removed. */ format?: components$d["parameters"]["format"]; /** * Controls filtering of trashed items. * * exclude: (default) Only return items not in trash. * only: Only return trashed items (for trash view). * include: Return both trashed and non-trashed items. */ deleted?: components$d["parameters"]["deleted"]; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": components$d["schemas"]["CompositionListResponse"] | components$d["schemas"]["CompositionApiResponse"]; }; }; 400: components$d["responses"]["BadRequestError"]; 401: components$d["responses"]["UnauthorizedError"]; 403: components$d["responses"]["ForbiddenError"]; /** Composition not found */ 404: { headers: { [name: string]: unknown; }; content: { "text/plain": string; }; }; 429: components$d["responses"]["RateLimitError"]; 500: components$d["responses"]["InternalServerError"]; }; }; /** Upserts a composition */ put: { parameters: { query?: never; header?: { /** * Optional concurrency control header. If provided, the server will check that the composition * has not been modified since this timestamp. If the timestamp doesn't match the current * modified timestamp, a 409 Conflict response will be returned. */ "X-If-Unmodified-Since"?: string; }; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** * Format: uuid * The project ID to upsert the composition to */ projectId: string; /** The publishing state to upsert into. 0 = draft, 64 = published */ state: number; composition: components$d["schemas"]["RootComponentInstance"]; /** * Indicates if the composition is a pattern that can be referenced in other compositions * @defaultValue false */ pattern?: boolean; /** This field is ignored if present */ created?: string; /** This field is ignored if present */ modified?: string; /** * Format: uuid * Reference to the category this component definition belongs to * @defaultValue null */ categoryId?: string | null; /** * A description of the component definition * @defaultValue null */ description?: string | null; /** * A preview image URL of the component definition * @defaultValue null */ previewImageUrl?: string | null; /** * Format: uuid * The release this composition belongs to. If not set, it belongs to the base */ releaseId?: string; /** * Format: uuid * The workflow ID assigned to this composition, if any */ workflowId?: string; /** * Format: uuid * The stage ID the composition is in within its assigned workflow. If undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** * Format: uuid * The edition ID. When set, this is a child edition of the composition in _id. */ editionId?: string; /** * The name of the composition or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or composition. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$d["responses"]["BadRequestError"]; 401: components$d["responses"]["UnauthorizedError"]; 403: components$d["responses"]["ForbiddenError"]; /** Conflict - Composition has been changed since being loaded */ 409: { headers: { [name: string]: unknown; }; content: { "text/plain": string; }; }; 429: components$d["responses"]["RateLimitError"]; 500: components$d["responses"]["InternalServerError"]; }; }; post?: never; /** Deletes or unpublishes a composition */ delete: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody: { content: { "application/json": { /** * Format: uuid * The ID of the composition to delete. * When editionId is also passed, the composition remains and an edition under it is deleted. * When editionId is omitted, and the composition has editions, all editions will also be deleted along with the composition. */ compositionId: string; /** * Format: uuid * The edition ID to delete. When set, this deletes a child edition of the compositionId. * The composition will remain when an edition is deleted. * If the composition ID is specified as the edition ID, the composition will be deleted _but any other editions will remain_ (this is used for unpublishing). */ editionId?: string; /** * Format: uuid * The ID of the project the composition to delete belongs to */ projectId: string; /** * Format: uuid * The release the composition to delete belongs to. If not set, it belongs to the base. * Note: Deleting a composition from a release will not delete the composition from the base */ releaseId?: string; /** The state to delete (0 = draft, 64 = published [causes unpublishing], unspecified = all) */ state?: number; }; }; }; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; 400: components$d["responses"]["BadRequestError"]; 401: components$d["responses"]["UnauthorizedError"]; 403: components$d["responses"]["ForbiddenError"]; 429: components$d["responses"]["RateLimitError"]; 500: components$d["responses"]["InternalServerError"]; }; }; /** Handles preflight requests. This endpoint allows CORS */ options: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; }; }; head?: never; patch?: never; trace?: never; }; } interface components$d { schemas: { CompositionApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Present only when `withUIStatus` is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown"; /** * Format: uuid * The project ID this composition is part of */ projectId: string; /** * Format: date-time * Created date string for this composition */ created: string; /** * Format: date-time * Modified date string for this composition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** User name of the creator of this composition */ creator?: string; /** User name of the last editor of this composition */ author?: string; /** * Format: uuid * Reference to the category this component definition belongs to */ categoryId?: string; /** A description of the component definition */ description?: string; /** A preview image URL of the component definition */ previewImageUrl?: string; /** Indicates if the composition is a pattern that can be referenced in other compositions */ pattern: boolean; /** * If the instance is a pattern, this indicates if it's a component pattern or a composition pattern */ patternType?: "component" | "composition"; /** * Format: uuid * The release this composition belongs to. If not set, it belongs to the base */ releaseId?: string; composition: components$d["schemas"]["RootComponentInstance"]; /** * Format: uuid * The workflow ID assigned to this composition, if any. Normally comes from the component definition */ workflowId?: string; /** * Format: uuid * The stage ID the composition is in within its assigned workflow. If undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Returned only when `withWorkflowDefinition` is true */ workflowDefinition?: components$d["schemas"]["WorkflowDefinition"]; /** * Format: uuid * The edition ID. When set, this is a child edition of the composition in _id. */ editionId?: string; /** * The name of the composition or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or composition. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; CompositionListResponse: { compositions: components$d["schemas"]["CompositionApiResponse"][]; /** Total number of compositions that match the query. Present only when `withTotalCount` option is true */ totalCount?: number; /** Per-field counts for distinct values */ facets?: { [key: string]: { [key: string]: number; }; }; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$d["schemas"]["VisibilityCriteria"] | components$d["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$d["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$d["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$d["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$d["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$d["schemas"]["ComponentParameterConditions"]; }; }; ProjectMapNodeAllowedQueryString: { /** The name of the query string parameter */ name: string; /** The default value of the query string if it is not provided by an incoming route path */ value?: string; /** Help text for authors who might be setting up a preview value for this query string */ helpText?: string; /** * Controls whether a global query string is always shown in Canvas or must be opted into. * This property is ignored on node-level query strings. When omitted, the query string is always shown. */ editorVisibility?: "opt-in"; /** Configuration for providing a list of allowed values for this query string */ optionsSource?: { /** * The source type for the options */ source: "static"; options: { /** Display name for the option */ name: string; /** The actual value to be used */ value: string; }[]; }; }; ProjectMapNodeData: { /** While performing a search if a node is a hit, this property will return true. If it's supporting structure, like a parent of a search hit, it will return false */ isSearchHit?: boolean; /** Query strings that are allowed to be passed to the node */ queryStrings?: components$d["schemas"]["ProjectMapNodeAllowedQueryString"][]; /** * For dynamic nodes, this is the preview value for the dynamic value. * The preview value is used when editing a connected composition, and is the default * dynamic node value unless the author has explicitly chosen a different value */ previewValue?: string; }; /** Project map node information related to a component */ CompositionProjectMapNodeInfo: { /** * Format: uuid * Unique identifier for the project map node */ id: string; /** * Fallback path of the project map node. * Note that the node may have matched via a locale-specific path which is in the `locales` object */ path: string; /** * Format: uuid * Unique identifier for the project map that this node belongs to */ projectMapId: string; data?: components$d["schemas"]["ProjectMapNodeData"]; /** * Locale-specific paths of the project map node. * Keys are locale codes */ locales?: { [key: string]: { /** Locale-specific path of the project map node */ path: string; /** Whether the path is inherited from a parent node which defined a path segment in this locale */ inherited: boolean; }; }; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$d["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$d["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$d["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$d["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$d["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$d["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$d["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$d["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$d["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$d["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$d["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$d["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$d["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$d["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** Defines the shape of the root component in a composition */ RootComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$d["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Project map nodes associated with this component. Must pass withProjectMapNodes parameter to be populated */ projectMapNodes?: components$d["schemas"]["CompositionProjectMapNodeInfo"][]; /** Slots containing any child components */ slots?: { [key: string]: components$d["schemas"]["ComponentInstance"][]; }; /** The ID of the composition */ _id: string; /** Slug pattern of this component */ _slug?: string | null; /** Friendly name of this component */ _name: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$d["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _dataResources?: components$d["schemas"]["DataResourceDefinitions"]; _patternError?: components$d["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$d["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$d["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$d["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the composition. If empty, the current default locale implicitly has data */ _locales?: string[]; /** * Names of opt-in global query strings surfaced in the Canvas editor for this composition or pattern. * Opt-ins coming from a resolved pattern move to _patternOptedInQueryStrings, so this always * holds only what was authored here. Omitted whenever overrides are resolved. */ _optedInQueryStrings?: string[]; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$d["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$d["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$d["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$d["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$d["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$d["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$d["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: { /** The project the composition(s) belong to */ projectId: string; /** * Specify a single composition ID to fetch. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters. * When `editions=raw`, this parameter matches on composition or edition IDs and edition resolution is disabled. */ compositionId: string; /** * Specify a single component ID to fetch the component's composition defaults. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ componentId: string; /** * Specify multiple composition IDs to fetch. The response type will be a list. * This is a primary query parameter and cannot be used with any other primary query parameters. * When `editions=raw`, this parameter matches on composition or edition IDs and edition resolution is disabled. */ compositionIDs: string[]; /** * Specify a historical composition version ID to fetch (retrieved from the canvas-history API). * Must be used with the `compositionId` parameter */ versionId: string; /** * Specify a single composition to fetch by slug. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ slug: string; /** * Specify a single composition to fetch by associated project map node ID. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ projectMapNodeId: string; /** * Specify a single composition to fetch by associated project map node path. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ projectMapNodePath: string; /** * Specify a project map ID to fetch by path or node ID from. * If not specified, the default project map for the projectId is used. * Only used when fetching by projectMapNodeId or projectMapNodePath */ projectMapId: string; /** * The component type (by public ID) to filter by. Note that this filters the root composition type only; components in slots are not matched by this filter. * This is a list query parameter and cannot be used with any primary query parameters */ type: string[]; /** * Publishing state to fetch. 0 = draft, 64 = published. * This is a list query parameter and cannot be used with any primary query parameters */ state: number; /** * Number of records to skip * This is a list query parameter and cannot be used with any primary query parameters */ offset: number; /** * Maximum number of records to return * This is a list query parameter and cannot be used with any primary query parameters */ limit: number; /** Filtration by category ID. An empty string can be used to include records without a category. */ categories: string[]; /** * @deprecated * Signals an enhancer proxy to skip processing enhancements to the data and return raw data only. * This improves performance if you do not require enhanced component data. * If calling the Canvas API directly with no enhancer proxy, this has no effect */ skipEnhance: boolean; /** * Specify a format you want the results in. Any explicit shaping flag (skipPatternResolution, * skipOverridesResolution, withComponentIDs) overrides this alias. * - `canonical`: PUT-safe structure — patterns and overrides left * unresolved and component `_id`s included. This is the format the Uniform CLI uses when syncing. * (skipPatternResolution=true, skipOverridesResolution=true, * withComponentIDs=true). * - `editor`: For loading into a Uniform editor - same as canonical, but with patterns expanded (skipPatternResolution=false). Still PUT-safe — the PUT ignores * the expanded pattern nodes. * - `delivery`: default structure for serving to a frontend — patterns and overrides resolved * and component `_id`s removed. */ format: "canonical" | "editor" | "delivery"; /** * If true, any pattern references in the composition will be left unresolved. * This is appropriate if you intend to serialize the composition without patterns * embedded into it, and serialize the pattern data separately. * Default: true when `format` is canonical. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipPatternResolution: boolean; /** * If true, any pattern override data is not resolved by the API. * This is intended for internal use in the Canvas editor and should not be used. * Passing this parameter automatically implies `withComponentIDs` is true. * Default: true when `format` is canonical or editor. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipOverridesResolution: boolean; /** * @deprecated * This parameter is unused and has no effect. Passing this parameter will become an error in the future */ skipParameterResolution: boolean; /** * If true, the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response. * Note: the default value depends on the `format`: true for editor or canonical, false for delivery or when no format is specified. * Prefer selecting a `format` rather than using this option. */ withComponentIDs: boolean; /** * Matches compositions where their name, slug, or definition name contains the specified keyword. * NOT a full-text search; does not match composition contents. * This is a list query parameter and cannot be used with any primary query parameters */ keyword: string; /** * Matches compositions based on whether they are a pattern composition or a regular composition. * If true, only pattern compositions will be returned. * If false, only regular compositions will be returned. * If omitted or 'any', both pattern and regular compositions will be returned. * This is a list query parameter and cannot be used with any primary query parameters */ pattern: boolean | "any"; /** * This specifies which type of patterns to return. This query parameter has no effect when `pattern` is false. * * `all` - Returns all pattern instances * * `component` - Returns only component patterns * * `composition` - Returns only composition patterns */ patternType: "all" | "component" | "composition"; /** * @deprecated * Includes the `patternType` attribute in the response */ withPatternType: boolean; /** * Sets the sorting of the results. If unspecified, results are sorted by name ascending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, * name_DESC, name_ASC, slug_DESC, slug_ASC. * When using primary query parameters, this parameter is ignored */ orderBy: string[]; /** * @deprecated * Returns counts for distinct values of the specified field or fields (provided as comma-separated IDs). */ facetBy: string; /** * @deprecated * Returns the UI status string of the composition. * This internal status is subject to change without notice and is thus marked deprecated to discourage use of internal data */ withUIStatus: boolean; /** Returns the definition of any attached workflow along with the composition data */ withWorkflowDefinition: boolean; /** * @deprecated * Filters composition lists by the UI status of the composition. * This internal status is subject to change without notice and is thus marked deprecated to discourage use of internal data. * This is a list query parameter and cannot be used with any primary query parameters */ uiStatus: ("Draft" | "Modified" | "Published" | "Orphan")[]; /** * Filters out compositions without attached node or filters out compositions with attached nodes * if set to false. If not specified, no filtration is applied. * This is a list query parameter and cannot be used with any primary query parameters */ attachedToProjectMap: boolean; /** Includes project map node information in the composition results */ withProjectMapNodes: boolean; /** * @deprecated * Has no effect. */ withContentSourceMap: boolean; /** * Filters composition lists by the user who created them. The user is specified by their identity subject. * This is a list query parameter and cannot be used with any primary query parameters */ createdBy: string; /** * Filters composition lists by the user who last updated them. The user is specified by their identity subject. * This is a list query parameter and cannot be used with any primary query parameters */ updatedBy: string; /** * Controls whether the total count of results will be returned along with the current results page in a list. * Has no effect when not fetching a list. This does impact performance when enabled */ withTotalCount: boolean; /** * One or more locales to filter and localize by. * For list responses, only compositions that enable one of the specified locales _or enable no locales_ will be returned. When more than one locale is passed, the list matches with an OR on each locale. * For all types of response, the response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned. * If a composition is requested by ID and does not possess any of the specified locales, HTTP 404 will be returned */ locale: string; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId: string; /** * Search on textual fields of a composition. * Matches against fully rendered content including resolved pattern content. * Use this for "where does this content appear" queries. * Note: For long text fields, the tail of the text is not guaranteed to be searchable. * Example: ?search=hello */ search: string; /** * @deprecated * BETA: Semantic search using vector similarity to find content by meaning. * Matches against source content only - pattern base content matches the pattern itself, not consumers. * Use this for "where is this content defined" queries. * Requires AI credits. */ searchSemantic: string; /** * Controls the edition resolution behavior. * * auto: (default) Editions are evaluated automatically and the best matching edition is returned. * When a locale is provided, the edition with the highest priority that enables that locale matches * Without a locale, the default edition is matched * * all: Every edition is returned as a separate row. * Note: this has no effect when used with compositionId which always returns a single result. * * raw: the compositionId and compositionIDs parameters target exact edition/composition IDs and no edition resolution is performed. * compositionId or compositionIDs MUST be provided with this option. * If versionId is passed, this is always enabled. */ editions: "auto" | "all" | "raw"; /** * Controls filtering of trashed items. * * exclude: (default) Only return items not in trash. * only: Only return trashed items (for trash view). * include: Return both trashed and non-trashed items. */ deleted: "exclude" | "only" | "include"; }; requestBodies: never; headers: never; pathItems: never; } interface paths$b { "/api/v1/canvas-history": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; get: { parameters: { query: { /** Specify the composition ID to get history for */ compositionId: string; /** The edition ID. When set, gets history for a child edition of the compositionId. */ editionId?: string; /** The project the composition(s) are on */ projectId: string; /** If a request returns a cursor, pass it in this query parameter to get the next page of results */ cursor?: string; /** The release ID to get history for. Note that release history is independent of base histories */ releaseId?: string; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": components$c["schemas"]["HistoryApiResponse"]; }; }; 400: components$c["responses"]["BadRequestError"]; 401: components$c["responses"]["UnauthorizedError"]; 403: components$c["responses"]["ForbiddenError"]; /** Composition not found */ 404: { headers: { [name: string]: unknown; }; content: { "text/plain": string; }; }; 429: components$c["responses"]["RateLimitError"]; 500: components$c["responses"]["InternalServerError"]; }; }; put?: never; post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; } interface components$c { schemas: { HistoryEntry: { /** The version ID of the entity. This can be used to fetch the version's data via the entity API */ versionId: string; /** The timestamp when the version was created in epoch milliseconds */ timestamp: number; /** The name (full name) of the user who created the version, or "Unknown user" if the author can no longer be resolved */ authorName: string; authorIsApiKey: boolean; /** The identity who created the version; absent on old history entries. */ authorSubject?: string; /** The state of the entity when the history entry was made */ state: number; }; HistoryApiResponse: { /** * If there are more results, this will be populated with a token to pass in the next request to get the next page of results. * If this is undefined then no more results are available */ cursor?: string; /** If more history is available than your plan allows, and additional entries are available by upgrading, this will be true */ truncated?: boolean; /** Version history entries */ results?: components$c["schemas"]["HistoryEntry"][]; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$c["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$c["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$c["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: never; requestBodies: never; headers: never; pathItems: never; } interface components$b { schemas: { CompositionResolvedGetResponse: components$b["schemas"]["EdgehancersResolutionInfo"] & components$b["schemas"]["CompositionApiResponse"]; CompositionResolvedListResponse: { diagnostics?: components$b["schemas"]["EdgehancersDiagnostics"] & { data?: { [key: string]: components$b["schemas"]["DataDiagnostic"][]; }; }; errors?: { [key: string]: components$b["schemas"]["DataResolutionIssue"][]; }; warnings?: { [key: string]: components$b["schemas"]["DataResolutionIssue"][]; }; infos?: { [key: string]: components$b["schemas"]["DataResolutionIssue"][]; }; } & components$b["schemas"]["CompositionListResponse"]; EntryResolvedListResponse: { diagnostics?: components$b["schemas"]["EdgehancersDiagnostics"] & { data?: { [key: string]: components$b["schemas"]["DataDiagnostic"][]; }; }; errors?: { [key: string]: components$b["schemas"]["DataResolutionIssue"][]; }; warnings?: { [key: string]: components$b["schemas"]["DataResolutionIssue"][]; }; infos?: { [key: string]: components$b["schemas"]["DataResolutionIssue"][]; }; } & components$b["schemas"]["EntryListResponse"]; EdgehancersResolutionInfo: { wholeResponseCacheDiagnostics?: { info: string; cacheTtl: number; cachedAt: string; edgeLocation?: string; requestId: string; }; diagnostics?: components$b["schemas"]["EdgehancersDiagnostics"] & { data?: components$b["schemas"]["DataDiagnostic"][]; }; errors?: components$b["schemas"]["DataResolutionIssue"][]; warnings?: components$b["schemas"]["DataResolutionIssue"][]; infos?: components$b["schemas"]["DataResolutionIssue"][]; }; EdgehancersError: { message: string; status: number; statusText: string; }; UniformError: components$b["schemas"]["EdgehancersError"] | components$b["schemas"]["Error"]; InvalidationPayload: { /** List of variables with values to invalidate */ variables?: { name: string; value: string; }[]; /** List of surrogate keys to invalidate */ surrogateKeys?: string[]; }; BatchInvalidationPayload: { dataTypeId: string; /** Format: uuid */ purgeKey: string; conditions?: components$b["schemas"]["InvalidationPayload"]; }[]; DataDiagnostic: { componentPath: string; dataType: string; dataName: string; performance: { cacheHit: boolean; total: number; retryCount: number; retryDelay: number; sourceCache?: string; /** Array of status codes for corresponding retries; will be empty for cache hits, Uniform Content data resources and static JSON data resources */ statusCodes: number[]; }; /** Projection descriptor for this data resource fetch. Recorded by the Uniform Content resolver as the serialized `select.*` query string applied to the upstream fetch (empty when no projection was applied) */ projection?: string; data: unknown; }; /** * Diagnostic information about request processing, including origin/config/data * * timings, edge locations, cache statuses and raw data. * * Only present when diagnostics=true is passed to the options */ EdgehancersDiagnostics: { /** Edge location where the request was processed */ edgeLocation?: string; originFetch?: { /** How long it took to fetch from the origin (ms) */ duration: number; /** Indicates if the origin response was cached */ cacheHit: boolean; /** Indicates if the request results in a valid response */ isValid: boolean; /** * Source cache used */ sourceCache?: "edge-cdn-cache" | "long-term-cache" | "api-cache"; /** Edge cache location used */ cacheLocation?: string; /** Uniform-specific request identifier */ requestId?: string; /** Query params that were stripped from the path during parameter normalization because they were not allowed anywhere in the project map. Only present when some params were actually ignored. */ ignoredQueryParams?: string[]; }; configRetrieval?: { /** How long it took to retrieve the config (ms, in parallel to origin fetch) */ duration: number; /** How many data type configs were retrieved */ dataTypeCount: number; }; }; DataResolutionIssue: { componentId?: string; componentPath?: string; componentType?: string; message: string; type: string; parameterName?: string; expression?: components$b["schemas"]["DataElementConnectionDefinition"]; dataName?: string; dataType?: string; inputName?: string; code?: string; locale?: string; conditionIndex?: number; clauseIndex?: number; /** HTTP status code when the issue originated from a downstream fetch (data resource issues only). */ statusCode?: number; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$b["schemas"]["VisibilityCriteria"] | components$b["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$b["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$b["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$b["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$b["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$b["schemas"]["ComponentParameterConditions"]; }; }; ProjectMapNodeAllowedQueryString: { /** The name of the query string parameter */ name: string; /** The default value of the query string if it is not provided by an incoming route path */ value?: string; /** Help text for authors who might be setting up a preview value for this query string */ helpText?: string; /** * Controls whether a global query string is always shown in Canvas or must be opted into. * This property is ignored on node-level query strings. When omitted, the query string is always shown. */ editorVisibility?: "opt-in"; /** Configuration for providing a list of allowed values for this query string */ optionsSource?: { /** * The source type for the options */ source: "static"; options: { /** Display name for the option */ name: string; /** The actual value to be used */ value: string; }[]; }; }; ProjectMapNodeData: { /** While performing a search if a node is a hit, this property will return true. If it's supporting structure, like a parent of a search hit, it will return false */ isSearchHit?: boolean; /** Query strings that are allowed to be passed to the node */ queryStrings?: components$b["schemas"]["ProjectMapNodeAllowedQueryString"][]; /** * For dynamic nodes, this is the preview value for the dynamic value. * The preview value is used when editing a connected composition, and is the default * dynamic node value unless the author has explicitly chosen a different value */ previewValue?: string; }; /** Project map node information related to a component */ CompositionProjectMapNodeInfo: { /** * Format: uuid * Unique identifier for the project map node */ id: string; /** * Fallback path of the project map node. * Note that the node may have matched via a locale-specific path which is in the `locales` object */ path: string; /** * Format: uuid * Unique identifier for the project map that this node belongs to */ projectMapId: string; data?: components$b["schemas"]["ProjectMapNodeData"]; /** * Locale-specific paths of the project map node. * Keys are locale codes */ locales?: { [key: string]: { /** Locale-specific path of the project map node */ path: string; /** Whether the path is inherited from a parent node which defined a path segment in this locale */ inherited: boolean; }; }; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$b["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$b["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$b["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$b["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$b["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$b["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$b["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$b["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$b["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$b["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$b["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$b["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$b["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$b["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** Defines the shape of the root component in a composition */ RootComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$b["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Project map nodes associated with this component. Must pass withProjectMapNodes parameter to be populated */ projectMapNodes?: components$b["schemas"]["CompositionProjectMapNodeInfo"][]; /** Slots containing any child components */ slots?: { [key: string]: components$b["schemas"]["ComponentInstance"][]; }; /** The ID of the composition */ _id: string; /** Slug pattern of this component */ _slug?: string | null; /** Friendly name of this component */ _name: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$b["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _dataResources?: components$b["schemas"]["DataResourceDefinitions"]; _patternError?: components$b["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$b["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$b["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$b["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the composition. If empty, the current default locale implicitly has data */ _locales?: string[]; /** * Names of opt-in global query strings surfaced in the Canvas editor for this composition or pattern. * Opt-ins coming from a resolved pattern move to _patternOptedInQueryStrings, so this always * holds only what was authored here. Omitted whenever overrides are resolved. */ _optedInQueryStrings?: string[]; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$b["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$b["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$b["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$b["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; CompositionApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Present only when `withUIStatus` is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown"; /** * Format: uuid * The project ID this composition is part of */ projectId: string; /** * Format: date-time * Created date string for this composition */ created: string; /** * Format: date-time * Modified date string for this composition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** User name of the creator of this composition */ creator?: string; /** User name of the last editor of this composition */ author?: string; /** * Format: uuid * Reference to the category this component definition belongs to */ categoryId?: string; /** A description of the component definition */ description?: string; /** A preview image URL of the component definition */ previewImageUrl?: string; /** Indicates if the composition is a pattern that can be referenced in other compositions */ pattern: boolean; /** * If the instance is a pattern, this indicates if it's a component pattern or a composition pattern */ patternType?: "component" | "composition"; /** * Format: uuid * The release this composition belongs to. If not set, it belongs to the base */ releaseId?: string; composition: components$b["schemas"]["RootComponentInstance"]; /** * Format: uuid * The workflow ID assigned to this composition, if any. Normally comes from the component definition */ workflowId?: string; /** * Format: uuid * The stage ID the composition is in within its assigned workflow. If undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Returned only when `withWorkflowDefinition` is true */ workflowDefinition?: components$b["schemas"]["WorkflowDefinition"]; /** * Format: uuid * The edition ID. When set, this is a child edition of the composition in _id. */ editionId?: string; /** * The name of the composition or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or composition. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; CompositionListResponse: { compositions: components$b["schemas"]["CompositionApiResponse"][]; /** Total number of compositions that match the query. Present only when `withTotalCount` option is true */ totalCount?: number; /** Per-field counts for distinct values */ facets?: { [key: string]: { [key: string]: number; }; }; }; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; RouteDynamicInputs: { [key: string]: string; }; Redirect: { /** * Format: uuid * Id of the redirect */ id?: string; /** Source meant to match a url that needs to be redirected */ sourceUrl: string; /** Target meant to be redirected to */ targetUrl: string; /** Redirect type to occur from this redirect */ targetStatusCode: number; /** * Format: uuid * Project map node related to the source this redirect */ sourceProjectMapNodeId?: string; /** * Format: uuid * Project map node related to the target this redirect */ targetProjectMapNodeId?: string; /** * Format: uuid * Project map related to this redirect */ projectMapId?: string; /** Signals the redirect engine to retain query string parameters to the target url */ sourceRetainQuerystring?: boolean; /** Incoming requests must match the domain that's defined in the redirection source */ sourceMustMatchDomain?: boolean; /** Rewritten url should match the protocol (http / https) of the incoming request instead of whatever is defined in the redirection target */ targetPreserveIncomingProtocol?: boolean; /** Rewritten url should match the domain of the incoming request regardless of what is defined in the redirection target */ targetPreserveIncomingDomain?: boolean; /** Merge incoming querystring with the querystring defined on the redirection target, taking the incoming querystring parameter where a merge is not possible */ targetMergeQuerystring?: boolean; /** Label as system generated or user generated */ labelAsSystem?: boolean; }; /** The route matches a redirection configured in Uniform */ RouteResponseRedirect: { /** The route that was matched in the redirects */ matchedRoute: string; dynamicInputs?: components$b["schemas"]["RouteDynamicInputs"]; /** @enum {string} */ type: "redirect"; redirect: components$b["schemas"]["Redirect"]; }; /** * The route does not match any configured redirections or compositions. * NOTE: This response differs from a HTTP 404, which indicates that the project map or project ID was not found. * Receiving this response with HTTP 200 means that the project was found, but the route did not match anything */ RouteResponseNotFound: { /** @enum {string} */ type: "notFound"; }; /** Defines the shape of the entry */ Entry: { /** Content type public ID of the entry */ type: string; /** * Format: uuid * The ID of the entry */ _id: string; /** The name of the entry */ _name?: string; /** The thumbnail URL of the entry */ _thumbnail?: string; /** The slug of the entry */ _slug?: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this content entry should be sourced from a pattern library pattern */ _pattern?: string; /** Array of locales that have data defined on the entry. If empty, the current default locale implicitly has data */ _locales?: string[]; /** Entry field values */ fields?: { [key: string]: components$b["schemas"]["ComponentParameter"]; }; _dataResources?: components$b["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$b["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, or not been published yet. * Means nothing for PUTs; it will be ignored */ _patternError?: "NOTFOUND" | "CYCLIC"; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$b["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$b["schemas"]["ComponentOverridability"]; }; EntryApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * Format: uuid * The release this entry belongs to. If not set, the entry belongs to the base */ releaseId?: string; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Only present when `withUIStatus` option is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous"; /** * Format: uuid * The project ID that this layout data is part of */ projectId: string; /** * Format: date-time, * Created date string for this definition */ created: string; /** * Format: date-time, * Modified date string for this definition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** * True if the entry is a pattern (which can be referenced on other entries) * @defaultValue false */ pattern?: boolean; entry: components$b["schemas"]["Entry"]; /** * Format: uuid * The workflow ID that this entry is assigned. Normally comes from the content type */ workflowId?: string; /** * Format: uuid * The stage ID the entry is in on its assigned workflow. When undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Only returned when `withWorkflowDefinition` is true */ workflowDefinition?: components$b["schemas"]["WorkflowDefinition"]; /** * Only present if an incomplete entry is returned; indicates reason for stubbing */ stubType?: "missing" | "tooDeep"; /** * Format: uuid * The edition ID. When set, this is a child edition of the entry in _id. */ editionId?: string; /** * The name of the entry or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or entry. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; EntryListResponse: { entries: components$b["schemas"]["EntryApiResponse"][]; /** Total number of entries that match the query. Only present when `withTotalCount` option is true */ totalCount?: number; /** Per-field counts for distinct values */ facets?: { [key: string]: { [key: string]: number; }; }; }; }; responses: { /** Invalid caller input came with the request */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** Provided token or API key does not have access to the requested resource */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** Provided token or API key does not allow this action */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** The requested resource does not exist */ NotFoundError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** Invalid method was used to call the endpoint */ MethodNotAllowedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** The request body could not be parsed or understood */ UnprocessableEntityError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** The endpoint is called too often */ RateLimitError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; /** An unexpected error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content: { "application/json": components$b["schemas"]["UniformError"]; }; }; }; parameters: { /** Enables additional diagnostics that will be attached to the response; set to "no-data" to skip data resource values while keeping metrics */ diagnostics: "true" | "false" | "no-data"; /** Controls how many levels deep content references should be resolved */ resolutionDepth: number; /** Max number of records to return */ limit: number; /** Includes stubs in the response (enabled by default); set to false to omit all stubs */ withStubs: boolean; /** Fetches unpublished data from all data resources which support unpublished data */ dataSourceVariant: "unpublished"; /** * Specify a single composition ID to fetch. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters. * When `editions=raw`, this parameter matches on composition or edition IDs and edition resolution is disabled. */ compositionId: string; /** * Specify a historical composition version ID to fetch (retrieved from the canvas-history API). * Must be used with the `compositionId` parameter */ versionId: string; /** * Specify multiple composition IDs to fetch. The response type will be a list. * This is a primary query parameter and cannot be used with any other primary query parameters. * When `editions=raw`, this parameter matches on composition or edition IDs and edition resolution is disabled. */ compositionIDs: string[]; /** * Filters composition lists by the user who created them. The user is specified by their identity subject. * This is a list query parameter and cannot be used with any primary query parameters */ createdBy: string; /** * Matches compositions where their name, slug, or definition name contains the specified keyword. * NOT a full-text search; does not match composition contents. * This is a list query parameter and cannot be used with any primary query parameters */ keyword: string; /** * Number of records to skip * This is a list query parameter and cannot be used with any primary query parameters */ offset: number; /** * Sets the sorting of the results. If unspecified, results are sorted by name ascending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, * name_DESC, name_ASC, slug_DESC, slug_ASC. * When using primary query parameters, this parameter is ignored */ orderBy: string[]; /** * Matches compositions based on whether they are a pattern composition or a regular composition. * If true, only pattern compositions will be returned. * If false, only regular compositions will be returned. * If omitted or 'any', both pattern and regular compositions will be returned. * This is a list query parameter and cannot be used with any primary query parameters */ pattern: boolean | "any"; /** The project the composition(s) belong to */ projectId: string; /** * Specify a project map ID to fetch by path or node ID from. * If not specified, the default project map for the projectId is used. * Only used when fetching by projectMapNodeId or projectMapNodePath */ projectMapId: string; /** * Specify a single composition to fetch by associated project map node ID. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ projectMapNodeId: string; /** * Specify a single composition to fetch by associated project map node path. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ projectMapNodePath: string; /** * @deprecated * Signals an enhancer proxy to skip processing enhancements to the data and return raw data only. * This improves performance if you do not require enhanced component data. * If calling the Canvas API directly with no enhancer proxy, this has no effect */ skipEnhance: boolean; /** * If true, any pattern references in the composition will be left unresolved. * This is appropriate if you intend to serialize the composition without patterns * embedded into it, and serialize the pattern data separately. * Default: true when `format` is canonical. False otherwise. * Prefer selecting a `format` rather than using this option. */ skipPatternResolution: boolean; /** * Specify a single composition to fetch by slug. The response will be a single composition. * This is a primary query parameter and cannot be used with any other primary query parameters */ slug: string; /** * Publishing state to fetch. 0 = draft, 64 = published. * This is a list query parameter and cannot be used with any primary query parameters */ state: number; /** * The component type (by public ID) to filter by. Note that this filters the root composition type only; components in slots are not matched by this filter. * This is a list query parameter and cannot be used with any primary query parameters */ type: string[]; /** * @deprecated * Filters composition lists by the UI status of the composition. * This internal status is subject to change without notice and is thus marked deprecated to discourage use of internal data. * This is a list query parameter and cannot be used with any primary query parameters */ uiStatus: ("Draft" | "Modified" | "Published" | "Orphan")[]; /** * Filters composition lists by the user who last updated them. The user is specified by their identity subject. * This is a list query parameter and cannot be used with any primary query parameters */ updatedBy: string; /** * If true, the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response. * Note: the default value depends on the `format`: true for editor or canonical, false for delivery or when no format is specified. * Prefer selecting a `format` rather than using this option. */ withComponentIDs: boolean; /** * Controls whether the total count of results will be returned along with the current results page in a list. * Has no effect when not fetching a list. This does impact performance when enabled */ withTotalCount: boolean; /** * @deprecated * Returns the UI status string of the composition. * This internal status is subject to change without notice and is thus marked deprecated to discourage use of internal data */ withUIStatus: boolean; /** * @deprecated * Has no effect. */ withContentSourceMap: boolean; /** * One or more locales to filter and localize by. * For list responses, only compositions that enable one of the specified locales _or enable no locales_ will be returned. When more than one locale is passed, the list matches with an OR on each locale. * For all types of response, the response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned. * If a composition is requested by ID and does not possess any of the specified locales, HTTP 404 will be returned */ locale: string; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId: string; /** * Search on textual fields of an entry. * Matches against fully rendered content including resolved pattern content. * Use this for "where does this content appear" queries. * Note: For long text fields, the tail of the text is not guaranteed to be searchable. * Example: ?search=hello */ search: string; /** * Controls the edition resolution behavior. * * auto: (default) Editions are evaluated automatically and the best matching edition is returned. * When a locale is provided, the edition with the highest priority that enables that locale matches * Without a locale, the default edition is matched * * all: Every edition is returned as a separate row. * * raw: the entryIDs parameter targets exact edition/entry IDs and no edition resolution is performed. * entryIDs MUST be provided with this option. * If versionId is passed, this is always enabled. */ editions: "auto" | "all" | "raw"; /** The project to fetch a route from */ "parameters-projectId": string; /** * The path to resolve. Dynamic project map nodes and redirects can be resolved when a matching path is passed. * Query string parameters may be passed with the path. They are ignored for route matching. * If the route matches a composition and the project map node allows passed query string parameters, query parameters will * be returned as as dynamic inputs to the composition. * * Examples: * * route "/company/about-us" would match "/company/about-us" in project map or redirects * * route "/products/123" would match "/products/:productId" in project map or "/products/*" in redirects * * route "/products/123?color=red" would match "/products/:productId" in project map, and provde productId=123 and color=red as dynamic inputs to the composition * * Conflict resolution: * If a route matches multiple possible project map or redirect nodes, the resulting action will use the following logic: * * If a redirect matches, it wins over project map nodes in all cases * * If multiple redirects or project map nodes match the route, the one with the most specific path wins: * * The route with the most path segments wins * * If several matches have the same number of segments, the one with the fewest dynamic segments wins * * If still ambiguous, the first matching route arbitrarily wins */ path: string; /** Specify a project map ID to fetch route from. If not specified, the default project map for the projectId is used */ "parameters-projectMapId": string; /** Publishing state to fetch. 0 = draft, 64 = published */ "parameters-state": number; /** * If true the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response */ "parameters-withComponentIDs": boolean; /** * One or more locales to localize the response to. * When the result is a composition, it includes only the first matching locale's data. * If no matching locale is found, the response will be a not-found result. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed: * - If a dynamic :locale path segment is defined on a project map ancestor node, then it will be used as the locale. If the path segment and this parameter are provided, the parameter takes precedence. * - Otherwise, all locales' data is returned. * * When the result is a redirect, this parameter has no effect */ "parameters-locale": string; /** * When true, redirects are not evaluated for the route matching; the result will be either a composition or not found. * Note: this is always true when state=63 (internal RSC editor state) to allow contextual editing of compositions * that have redirects configured on their paths. */ ignoreRedirects: boolean; /** The project the entry/entries are on */ "components-parameters-projectId": string; /** * Specify one or more entry IDs to fetch. * When `editions=raw`, this matches on edition IDs or entry IDs and edition resolution is disabled. * When `versionId` is passed, this parameter is required and must contain only one entry ID. */ entryIDs: string[]; /** Specify a single entry to fetch by slug */ "parameters-slug": string; /** Filters entry lists by the user who created them. The user is specified by their identity subject */ "parameters-createdBy": string; /** Number of records to skip */ "parameters-offset": number; /** * Sets the sorting of the results. If unspecified, results are sorted by modification date descending. * Allowed values are: updated_at_DESC, updated_at_ASC, created_at_DESC, created_at_ASC, name_DESC, name_ASC, slug_DESC, slug_ASC */ "parameters-orderBy": string[]; /** The content type ID to filter by */ "parameters-type": string[]; /** * @deprecated * Filters entries lists by the UI status of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ "parameters-uiStatus": ("Draft" | "Modified" | "Published" | "Orphan")[]; /** Filters entry lists by the user who last updated them. The user is specified by their identity subject */ "parameters-updatedBy": string; /** * @deprecated * Returns the UI status string of the entry. * This internal status is subject to change without notice, and is thus marked deprecated to discourage use of internal data */ "parameters-withUIStatus": boolean; /** * One or more locales to filter and localize by. * Only entries that enable one of the specified locales _or enable no locales_ will be returned. * The response will be localized to include only the first matching locale's data. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed, all locales' data will be returned */ "components-parameters-locale": string; }; requestBodies: never; headers: never; pathItems: never; } interface paths$a { "/api/v1/route": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; /** * Fetches the correct response action for a given route (redirection, composition, not found). * * In addition to the named parameters below, this endpoint accepts data projection syntax: * `select.[]` — documented below. * * #### Data projection (`select.*`) * * Projection returns a subset of the matched composition by pruning fields * (parameters), field types, and slots before values are resolved. It only * applies when the route resolves to a composition; redirect and notFound * responses are returned unchanged. The allowed names are project-specific — * they come from the project's component definitions and content types — * which is why `select.*` parameters are pattern-validated rather than * declared as named parameters. * * Syntax: `select.[]=`. Values are comma-separated * lists of names. `*` is the only wildcard and matches zero or more * characters (e.g. `seo_*`). * * | Parameter | Effect | * |---|---| * | `select.fields[only]=a,b` | Keep only the named fields/parameters; drop everything else. | * | `select.fields[except]=a,b` | Drop the named fields/parameters; keep everything else. | * | `select.fields[locales]=a,b` | For the named fields that survive filtering, return the full per-locale value map instead of only the requested locale's value. | * | `select.fields[blockDepth]=N` | Limit how many levels of block field children are kept. `0` removes all block fields; `preserveAll` prevents projection from trimming fields inside block children. | * | `select.fieldTypes[only]=a,b` | Keep only fields of the named types (type IDs such as `text`, `richText`, `asset`). | * | `select.fieldTypes[except]=a,b` | Drop fields of the named types. | * | `select.slots[only]=a,b` | Keep only the named slots. | * | `select.slots[except]=a,b` | Drop the named slots. | * | `select.slots[depth]=N` | Limit how many levels of nested components are kept in slots. | * | `select.slots.[depth]=N` | Depth limit for one specific slot; overrides `slots[depth]`. | * * Behavior: * * * Projection applies recursively at every component and block in the * returned tree, and is forwarded into entries resolved through reference * fields. * * When operators combine, all `[only]` sets are intersected first, then * `[except]` sets are subtracted — exclusion always wins. * * Unknown field, slot, or type names are silent no-ops (the tree shape is * preserved; non-matching content is simply absent). Unknown operators * return HTTP 400. * * An empty list (`select.fields[only]=` or `select.slots[only]=`) strips * every member of that bucket; `[except]=*` is equivalent. * * `[depth]` counts nesting within a single fetched tree and resets inside * referenced entries. * * Examples: * * * `select.fields[only]=title,slug&select.slots[only]=` — title and slug of the resolved page with all slots flattened (e.g. for breadcrumbs). * * `select.fieldTypes[except]=richText` — everything except rich-text fields. * * `select.slots[depth]=2&select.fields[only]=label,url` — two levels of nested components, trimmed to `label` and `url`. */ get: { parameters: { query: { /** The project to fetch a route from */ projectId: components$a["parameters"]["projectId"]; /** * The path to resolve. Dynamic project map nodes and redirects can be resolved when a matching path is passed. * Query string parameters may be passed with the path. They are ignored for route matching. * If the route matches a composition and the project map node allows passed query string parameters, query parameters will * be returned as as dynamic inputs to the composition. * * Examples: * * route "/company/about-us" would match "/company/about-us" in project map or redirects * * route "/products/123" would match "/products/:productId" in project map or "/products/*" in redirects * * route "/products/123?color=red" would match "/products/:productId" in project map, and provde productId=123 and color=red as dynamic inputs to the composition * * Conflict resolution: * If a route matches multiple possible project map or redirect nodes, the resulting action will use the following logic: * * If a redirect matches, it wins over project map nodes in all cases * * If multiple redirects or project map nodes match the route, the one with the most specific path wins: * * The route with the most path segments wins * * If several matches have the same number of segments, the one with the fewest dynamic segments wins * * If still ambiguous, the first matching route arbitrarily wins */ path: components$a["parameters"]["path"]; /** Specify a project map ID to fetch route from. If not specified, the default project map for the projectId is used */ projectMapId?: components$a["parameters"]["projectMapId"]; /** Publishing state to fetch. 0 = draft, 64 = published */ state?: components$a["parameters"]["state"]; /** * If true the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response */ withComponentIDs?: components$a["parameters"]["withComponentIDs"]; /** * @deprecated * Has no effect. */ withContentSourceMap?: components$a["parameters"]["withContentSourceMap"]; /** * One or more locales to localize the response to. * When the result is a composition, it includes only the first matching locale's data. * If no matching locale is found, the response will be a not-found result. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed: * - If a dynamic :locale path segment is defined on a project map ancestor node, then it will be used as the locale. If the path segment and this parameter are provided, the parameter takes precedence. * - Otherwise, all locales' data is returned. * * When the result is a redirect, this parameter has no effect */ locale?: components$a["parameters"]["locale"]; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId?: components$a["parameters"]["releaseId"]; /** * Indicates the data variant that was fetched for data resources. * undefined: Data resources were resolved using published data from their data source * unpublished: Data resources which support unpublished data retrieved unpublished data from their data source. Data resources that did not support unpublished data retrieved published data instead. */ dataSourceVariant?: components$a["parameters"]["dataSourceVariant"]; /** * When true, redirects are not evaluated for the route matching; the result will be either a composition or not found. * Note: this is always true when state=63 (internal RSC editor state) to allow contextual editing of compositions * that have redirects configured on their paths. */ ignoreRedirects?: components$a["parameters"]["ignoreRedirects"]; }; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 200: { headers: { [name: string]: unknown; }; content: { "application/json": components$a["schemas"]["RouteResponse"]; }; }; 400: components$a["responses"]["BadRequestError"]; 401: components$a["responses"]["UnauthorizedError"]; 403: components$a["responses"]["ForbiddenError"]; 429: components$a["responses"]["RateLimitError"]; 500: components$a["responses"]["InternalServerError"]; }; }; put?: never; post?: never; delete?: never; /** Handles preflight requests. This endpoint allows CORS */ options: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; requestBody?: never; responses: { /** OK */ 204: { headers: { [name: string]: unknown; }; content?: never; }; }; }; head?: never; patch?: never; trace?: never; }; } interface components$a { schemas: { RouteDynamicInputs: { [key: string]: string; }; Redirect: { /** * Format: uuid * Id of the redirect */ id?: string; /** Source meant to match a url that needs to be redirected */ sourceUrl: string; /** Target meant to be redirected to */ targetUrl: string; /** Redirect type to occur from this redirect */ targetStatusCode: number; /** * Format: uuid * Project map node related to the source this redirect */ sourceProjectMapNodeId?: string; /** * Format: uuid * Project map node related to the target this redirect */ targetProjectMapNodeId?: string; /** * Format: uuid * Project map related to this redirect */ projectMapId?: string; /** Signals the redirect engine to retain query string parameters to the target url */ sourceRetainQuerystring?: boolean; /** Incoming requests must match the domain that's defined in the redirection source */ sourceMustMatchDomain?: boolean; /** Rewritten url should match the protocol (http / https) of the incoming request instead of whatever is defined in the redirection target */ targetPreserveIncomingProtocol?: boolean; /** Rewritten url should match the domain of the incoming request regardless of what is defined in the redirection target */ targetPreserveIncomingDomain?: boolean; /** Merge incoming querystring with the querystring defined on the redirection target, taking the incoming querystring parameter where a merge is not possible */ targetMergeQuerystring?: boolean; /** Label as system generated or user generated */ labelAsSystem?: boolean; }; /** The route matches a redirection configured in Uniform */ RouteResponseRedirect: { /** The route that was matched in the redirects */ matchedRoute: string; dynamicInputs?: components$a["schemas"]["RouteDynamicInputs"]; /** @enum {string} */ type: "redirect"; redirect: components$a["schemas"]["Redirect"]; }; /** Defines a connection to a dynamic token on a data resource */ DataElementConnectionDefinition: { /** A JSON Pointer expression that defines the data resource dynamic token value */ pointer: string; /** * The syntax used to select the dynamic token to bind to */ syntax: "jptr"; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: If the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: If the _failureDefault_ property is also set, that default value will be used instead of removing the token. * this only applies when the failureAction is 't' or undefined, the default is otherwise ignored * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or an entry, * it is treated as an 'a' failure because removing the root means we must remove all * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses */ failureAction?: "t" | "p" | "c" | "a"; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Log an informative message (failure is expected/normal, i.e. optional data) */ failureLogLevel?: "e" | "w" | "i"; /** * The default value to use if the dynamic token cannot be resolved. * This is only used if the failureAction is the default (undefined, or explicitly token) */ failureDefault?: string; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteria: { /** The rule type to execute */ rule: string; /** * The source value of the rule. * For rules which have multiple classes of match, for example a dynamic input matches on a named DI, the rule is dynamic input and the DI name is the source. */ source?: string; /** The rule-definition-specific operator to test against */ op: string; /** The value, or if an array several potential values, to test against. In most rules, multiple values are OR'd together ('any of') but this is not a hard requirement. */ value: string | string[]; }; /** * @deprecated * beta functionality subject to change */ VisibilityCriteriaGroup: { /** * The boolean operator to join the clauses with. Defaults to & if not specified. */ op?: "&" | "|"; clauses: (components$a["schemas"]["VisibilityCriteria"] | components$a["schemas"]["VisibilityCriteriaGroup"])[]; }; /** Defines a conditional value for a component parameter */ ComponentParameterConditionalValue: { when: components$a["schemas"]["VisibilityCriteriaGroup"]; /** * The value of the parameter. Any JSON-serializable value is acceptable. * A value of `null` will cause the parameter value to be removed, if it matches. */ value: unknown; /** * Unique sequence identifier of the conditional value within the component parameter. * This value must be unique within the conditional values array, and it should not change after a condition is created. */ id: number; }; /** * Array of alternate values which are based on conditions. * * When requested with an explicit locale parameter, or via the route API: * * Conditions are evaluated sequentially and the first match is used. If a match is found, the conditions are eliminated. * * If no conditions match, the `value` property is used. * * If a condition cannot be evaluated yet (i.e. a client-side criteria), it is left alone. * * When no locale is passed to a non-route API, conditions are not processed and all conditions are returned. */ ComponentParameterConditions: components$a["schemas"]["ComponentParameterConditionalValue"][]; /** Defines an editable parameter on a component */ ComponentParameter: { /** The value of the parameter. Any JSON-serializable value is acceptable */ value?: unknown; /** The type of the parameter. Determines how it is displayed when editing and tells the consumer how to process it */ type: string; /** @deprecated */ connectedData?: components$a["schemas"]["DataElementConnectionDefinition"]; /** * Locale-specific values for this parameter. Keys are locale codes, and values are the `value` in that locale. * Note that locales must be registered on the entry/composition `_locales` before being used */ locales?: { [key: string]: unknown; }; conditions?: components$a["schemas"]["ComponentParameterConditions"]; /** Locale-specific conditional values for this parameter. Keys are locale codes, and values are the `conditions` for that locale. */ localesConditions?: { [key: string]: components$a["schemas"]["ComponentParameterConditions"]; }; }; ProjectMapNodeAllowedQueryString: { /** The name of the query string parameter */ name: string; /** The default value of the query string if it is not provided by an incoming route path */ value?: string; /** Help text for authors who might be setting up a preview value for this query string */ helpText?: string; /** * Controls whether a global query string is always shown in Canvas or must be opted into. * This property is ignored on node-level query strings. When omitted, the query string is always shown. */ editorVisibility?: "opt-in"; /** Configuration for providing a list of allowed values for this query string */ optionsSource?: { /** * The source type for the options */ source: "static"; options: { /** Display name for the option */ name: string; /** The actual value to be used */ value: string; }[]; }; }; ProjectMapNodeData: { /** While performing a search if a node is a hit, this property will return true. If it's supporting structure, like a parent of a search hit, it will return false */ isSearchHit?: boolean; /** Query strings that are allowed to be passed to the node */ queryStrings?: components$a["schemas"]["ProjectMapNodeAllowedQueryString"][]; /** * For dynamic nodes, this is the preview value for the dynamic value. * The preview value is used when editing a connected composition, and is the default * dynamic node value unless the author has explicitly chosen a different value */ previewValue?: string; }; /** Project map node information related to a component */ CompositionProjectMapNodeInfo: { /** * Format: uuid * Unique identifier for the project map node */ id: string; /** * Fallback path of the project map node. * Note that the node may have matched via a locale-specific path which is in the `locales` object */ path: string; /** * Format: uuid * Unique identifier for the project map that this node belongs to */ projectMapId: string; data?: components$a["schemas"]["ProjectMapNodeData"]; /** * Locale-specific paths of the project map node. * Keys are locale codes */ locales?: { [key: string]: { /** Locale-specific path of the project map node */ path: string; /** Whether the path is inherited from a parent node which defined a path segment in this locale */ inherited: boolean; }; }; }; /** Defines the shape of a component instance served by the composition API */ ComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$a["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Slots containing any child components */ slots?: { [key: string]: components$a["schemas"]["ComponentInstance"][]; }; /** * Unique identifier of the component within the composition. * No assumptions should be made about the format of this value other than "it will be unique." * This is not returned in GET replies unless specifically requested via `withComponentIDs` API parameter. * When updating or creating a composition, if you do not specify an _id for each component, one will be created and stored for you */ _id?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; _dataResources?: components$a["schemas"]["DataResourceDefinitions"]; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$a["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _patternError?: components$a["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$a["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$a["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$a["schemas"]["ComponentOverridability"]; /** Array of locales that have data defined. Only set for pattern references or composition defaults */ _locales?: string[]; }; /** Variable values for a data resource */ DataResourceVariables: { [key: string]: string; }; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ DataResourceDefinition: { /** Public ID of the data type that provides this data */ type: string; /** Whether this data is a pattern data resource that can be overridden when a pattern is referenced on another composition. If this is not a pattern composition, this has no meaning and should not be used. If unspecified, the default is false */ isPatternParameter?: boolean; /** * When true, the default data resource of a pattern data parameter (isPatternParameter=true) will be ignored when the pattern is referenced. * Unless specifically overridden, the pattern data parameter will be provided with a null default value - leaving any data connections to it unresolvable. * If isPatternParameter is false or undefined, this has no meaning */ ignorePatternParameterDefault?: boolean; /** * When true, the data resource does not create an error forcing the choosing of override value when there is no default. * If isPatternParameter is false or undefined, or if ignorePatternParameterDefault is false, this has no meaning */ optionalPatternParameter?: boolean; variables?: components$a["schemas"]["DataResourceVariables"]; }; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key) */ DataResourceDefinitions: { [key: string]: components$a["schemas"]["DataResourceDefinition"]; }; /** * Describes why the pattern could not be resolved, if a pattern could not be resolved. For PUTs, this is allowed but ignored. * CYCLIC: A cyclic pattern graph was detected, which could not be resolved because it would cause an infinite loop. * NOTFOUND: The pattern ID referenced could not be found. It may have been deleted, en published yet. * Means nothing for PUTs; it will be ignored */ PatternError: "NOTFOUND" | "CYCLIC"; /** * Defines how to override a specific component. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverride: { parameters?: { [key: string]: components$a["schemas"]["ComponentParameter"]; }; slots?: { [key: string]: components$a["schemas"]["ComponentInstance"][]; }; variant?: string; /** * Overrides data resource definitions for a pattern component. * Object keys defined under this property override the corresponding keys in the pattern's data resources. * Overrides defined here replace values in either _dataResources or _patternDataResources on the target component. */ dataResources?: { [key: string]: components$a["schemas"]["DataResourceDefinition"]; }; }; /** * Whether a parameter is overridable * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ OverrideOptions: "yes" | "no"; /** * Defines how a component on a pattern may have its values overridden. * NOTE: Data resources' overridability is defined in the data resource definition, not here. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ ComponentOverridability: { /** Defines component parameter value overrides. Keys are the parameter public ID */ parameters?: { [key: string]: components$a["schemas"]["OverrideOptions"]; }; /** Allows overriding a display variant is allowed if it is defined on the component the pattern is derived from. Default = false */ variants?: boolean; /** * If true, parameters that are not overridable will be hidden by default on pattern instances' editors. * If false, all parameters will be shown on pattern instances' editors, but locked parameters will be read-only. * If not set, the default is false */ hideLockedParameters?: boolean; }; /** Defines the shape of the root component in a composition */ RootComponentInstance: { /** Type of the component instance (public_id of its definition) */ type: string; /** Component parameter values for the component instance */ parameters?: { [key: string]: components$a["schemas"]["ComponentParameter"]; }; /** Public ID of alternate visual appearance for this component, if any selected */ variant?: string; /** Project map nodes associated with this component. Must pass withProjectMapNodes parameter to be populated */ projectMapNodes?: components$a["schemas"]["CompositionProjectMapNodeInfo"][]; /** Slots containing any child components */ slots?: { [key: string]: components$a["schemas"]["ComponentInstance"][]; }; /** The ID of the composition */ _id: string; /** Slug pattern of this component */ _slug?: string | null; /** Friendly name of this component */ _name: string; /** Name of the author of the most recent change */ _author?: string; /** Identity subject of the author of the most recent change */ _authorSubject?: string; /** Name of the original creator */ _creator?: string; /** Identity subject of the original creator */ _creatorSubject?: string; /** Indicates this component instance should be sourced from a pattern library pattern */ _pattern?: string; /** * Data definitions coming from a pattern resolved for this component. Merged with _dataResources during resolution. * Means nothing for PUTs; it will be ignored */ _patternDataResources?: { [key: string]: components$a["schemas"]["DataResourceDefinition"]; }; /** * Query-string opt-ins coming from a pattern resolved for this component. * Means nothing for PUTs; it will be ignored */ _patternOptedInQueryStrings?: string[]; _dataResources?: components$a["schemas"]["DataResourceDefinitions"]; _patternError?: components$a["schemas"]["PatternError"]; /** * Defines patch overrides to component IDs that live in the composition. * This can be used to override parameters that are defined on patterns, * including nested patterns, with values that are specific to this composition. * The keys in this object are component IDs. * Overrides are applied from the top down, so for example if both the composition * and a pattern on the composition define an override on a nested pattern, * the composition's override replaces the pattern's. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overrides?: { [key: string]: components$a["schemas"]["ComponentOverride"]; }; /** * Overrides coming from a pattern resolved for this component. Merged with _overrides during resolution. * Means nothing for PUTs; it will be ignored */ _patternOverrides?: { [key: string]: components$a["schemas"]["ComponentOverride"]; }; /** * When used on a pattern, defines how the pattern's parameters may be overridden * by consumers of the pattern. * * NOTE: This is considered an internal data structure and is not guaranteed to be stable. * Future updates that do not break the overrides-applied state of a composition may be made without notice */ _overridability?: components$a["schemas"]["ComponentOverridability"]; /** Array of locales which have data defined on the composition. If empty, the current default locale implicitly has data */ _locales?: string[]; /** * Names of opt-in global query strings surfaced in the Canvas editor for this composition or pattern. * Opt-ins coming from a resolved pattern move to _patternOptedInQueryStrings, so this always * holds only what was authored here. Omitted whenever overrides are resolved. */ _optedInQueryStrings?: string[]; }; /** Permissions for a workflow stage */ WorkflowStagePermission: { /** Allows writing to entities assigned to this stage. When false or unspecified the data is read-only */ write?: boolean; /** Allows publishing entities assigned to this stage. When false or unspecified publishing is disabled */ publish?: boolean; }; /** Permissions for a workflow stage transition */ WorkflowStageTransitionPermission: { /** Allows executing the transition for a role. Note that write permissions to the destination stage are NOT required to execute a transition to it */ execute?: boolean; }; /** Definition of a transition from one stage to another in a workflow */ WorkflowStageTransition: { /** * Format: uuid * The target stage to transition to */ to: string; /** * Name shown to the user when they execute this transition. * If not provided, a default name will be assigned automatically based on the target stage */ name: string; /** * Permissions for the stage transition. * NOTE: Users without membership in any role listed here will be unable to execute the transition unless they are team admins */ permissions: { [key: string]: components$a["schemas"]["WorkflowStageTransitionPermission"]; }; }; /** Definition of a stage in a workflow */ WorkflowStage: { /** Name of the stage */ name: string; /** * Defines roles which have permissions to this workflow stage * NOTE: Being able to write or publish to entities in a workflow stage requires both core write or publish permissions, * as well as membership in a role which grants the explicit rights to the stage. If a user is not a member of any role * listed here, the stage is read-only and publishing is disabled */ permissions: { [key: string]: components$a["schemas"]["WorkflowStagePermission"]; }; /** * When true, transitioning into this stage from a different stage will automatically publish the entity. * If the user making the transition does not have publish permissions to the stage as well as publish permission on the entity, the action will not run. * Setting this to true is equivalent to setting requireValidity to true, as publishing cannot be performed with validation errors. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ autoPublish?: boolean; /** * When true, transitioning into this stage from a different stage will require the entity to have no validation errors. * If the entity is not valid, the transition will not be allowed. * NOTE: This is not executed by direct API calls. Only the Uniform UI performs this action */ requireValidity?: boolean; /** * Defines transitions to other stages * Every stage must define at least one transition, to avoid creating a workflow that * has a stage that can never be escaped */ transitions: components$a["schemas"]["WorkflowStageTransition"][]; /** * Icon name for the stage (e.g. 'chevron-double-right-o') * @defaultValue chevron-double-right-o */ icon?: string; /** Sets the order of the stage when displayed in a list with other stages. If not set, the order defaults to alphabetical with any explicitly set orders first in the list */ order?: number; }; /** Definition of a workflow that can be assigned to entities */ WorkflowDefinition: { /** * Format: uuid * Unique identifier of the workflow definition */ id: string; /** Workflow name */ name: string; /** * Format: uuid * The ID of the initial stage in the stages object. */ initialStage: string; /** All stages of the workflow */ stages: { [key: string]: components$a["schemas"]["WorkflowStage"]; }; /** Last modified ISO date string for this definition (ignored for writes) */ modified?: string; /** Created ISO date string for this definition (ignored for writes) */ created?: string; /** * Name of the original creator of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ createdBy?: string; /** * Name of the last modifier of the workflow. * If undefined, the user has been removed from the team. * Ignored for writes */ modifiedBy?: string; }; CompositionApiResponse: { /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * @deprecated * UI status value. Subject to change without notice; do not rely on this value. Present only when `withUIStatus` is true */ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown"; /** * Format: uuid * The project ID this composition is part of */ projectId: string; /** * Format: date-time * Created date string for this composition */ created: string; /** * Format: date-time * Modified date string for this composition */ modified: string; /** * Format: date-time * Timestamp when the item was moved to trash. Omitted if not in trash. */ deletedAt?: string; /** User name of the creator of this composition */ creator?: string; /** User name of the last editor of this composition */ author?: string; /** * Format: uuid * Reference to the category this component definition belongs to */ categoryId?: string; /** A description of the component definition */ description?: string; /** A preview image URL of the component definition */ previewImageUrl?: string; /** Indicates if the composition is a pattern that can be referenced in other compositions */ pattern: boolean; /** * If the instance is a pattern, this indicates if it's a component pattern or a composition pattern */ patternType?: "component" | "composition"; /** * Format: uuid * The release this composition belongs to. If not set, it belongs to the base */ releaseId?: string; composition: components$a["schemas"]["RootComponentInstance"]; /** * Format: uuid * The workflow ID assigned to this composition, if any. Normally comes from the component definition */ workflowId?: string; /** * Format: uuid * The stage ID the composition is in within its assigned workflow. If undefined, it is implicitly in the initial stage of the workflow */ workflowStageId?: string; /** The full definition of the assigned workflow, if any, including stages, permissions, etc. Returned only when `withWorkflowDefinition` is true */ workflowDefinition?: components$a["schemas"]["WorkflowDefinition"]; /** * Format: uuid * The edition ID. When set, this is a child edition of the composition in _id. */ editionId?: string; /** * The name of the composition or edition as shown in the editions listing. * Describes the purpose of an edition. */ editionName?: string; /** * The priority of the edition or composition. Higher numbers are higher priority. * When multiple editions enable the same locale, the highest priority edition is used. */ editionPriority?: number; }; /** * The route matches a composition. * If any dynamic segments or query parameters are present in the route, they will be returned as dynamic inputs in the response */ RouteResponseComposition: { /** The route that was matched in the project map */ matchedRoute: string; dynamicInputs?: components$a["schemas"]["RouteDynamicInputs"]; /** * Indicates the data variant that was fetched for data resources. * undefined: Data resources were resolved using published data from their data source * unpublished: Data resources which support unpublished data retrieved unpublished data from their data source. Data resources that did not support unpublished data retrieved published data instead. */ dataResourcesVariant?: "unpublished"; /** @enum {string} */ type: "composition"; compositionApiResponse: components$a["schemas"]["CompositionApiResponse"]; }; /** * The route does not match any configured redirections or compositions. * NOTE: This response differs from a HTTP 404, which indicates that the project map or project ID was not found. * Receiving this response with HTTP 200 means that the project was found, but the route did not match anything */ RouteResponseNotFound: { /** @enum {string} */ type: "notFound"; }; RouteResponse: components$a["schemas"]["RouteResponseRedirect"] | components$a["schemas"]["RouteResponseComposition"] | components$a["schemas"]["RouteResponseNotFound"]; Error: { /** Error message(s) that occurred while processing the request */ errorMessage?: string[] | string; }; }; responses: { /** Request input validation failed */ BadRequestError: { headers: { [name: string]: unknown; }; content: { "application/json": components$a["schemas"]["Error"]; }; }; /** API key or token was not valid */ UnauthorizedError: { headers: { [name: string]: unknown; }; content: { "application/json": components$a["schemas"]["Error"]; }; }; /** Permission was denied */ ForbiddenError: { headers: { [name: string]: unknown; }; content: { "application/json": components$a["schemas"]["Error"]; }; }; /** Too many requests in allowed time period */ RateLimitError: { headers: { [name: string]: unknown; }; content?: never; }; /** Execution error occurred */ InternalServerError: { headers: { [name: string]: unknown; }; content?: never; }; }; parameters: { /** The project to fetch a route from */ projectId: string; /** * The path to resolve. Dynamic project map nodes and redirects can be resolved when a matching path is passed. * Query string parameters may be passed with the path. They are ignored for route matching. * If the route matches a composition and the project map node allows passed query string parameters, query parameters will * be returned as as dynamic inputs to the composition. * * Examples: * * route "/company/about-us" would match "/company/about-us" in project map or redirects * * route "/products/123" would match "/products/:productId" in project map or "/products/*" in redirects * * route "/products/123?color=red" would match "/products/:productId" in project map, and provde productId=123 and color=red as dynamic inputs to the composition * * Conflict resolution: * If a route matches multiple possible project map or redirect nodes, the resulting action will use the following logic: * * If a redirect matches, it wins over project map nodes in all cases * * If multiple redirects or project map nodes match the route, the one with the most specific path wins: * * The route with the most path segments wins * * If several matches have the same number of segments, the one with the fewest dynamic segments wins * * If still ambiguous, the first matching route arbitrarily wins */ path: string; /** Specify a project map ID to fetch route from. If not specified, the default project map for the projectId is used */ projectMapId: string; /** Publishing state to fetch. 0 = draft, 64 = published */ state: number; /** * If true the `_id` unique identifier of each non-root component will be part of the response data. * If false, the `_id` will not be present in the API response */ withComponentIDs: boolean; /** * @deprecated * Has no effect. */ withContentSourceMap: boolean; /** * One or more locales to localize the response to. * When the result is a composition, it includes only the first matching locale's data. * If no matching locale is found, the response will be a not-found result. * * This parameter accepts a single value, a comma-delimited list of values, or the Accept-Language header syntax. Examples: * en-US * fr-CA,fr * de-AT;q=0.9,de-DE;q=0.8,en;q=0.7 * * When this parameter is not passed: * - If a dynamic :locale path segment is defined on a project map ancestor node, then it will be used as the locale. If the path segment and this parameter are provided, the parameter takes precedence. * - Otherwise, all locales' data is returned. * * When the result is a redirect, this parameter has no effect */ locale: string; /** * The ID of a release to fetch the content for. * * - When unspecified, all release content is excluded from the result(s). * - When specified, all content is returned as it would appear in the release if it was released now. This includes both content copied to the release and changed, as well as content that is not part of the release. * * Content copied to a release can be differentiated from base content by the `releaseId` property on the content. If the content is not copied to the release, this property will be null */ releaseId: string; /** * Indicates the data variant that was fetched for data resources. * undefined: Data resources were resolved using published data from their data source * unpublished: Data resources which support unpublished data retrieved unpublished data from their data source. Data resources that did not support unpublished data retrieved published data instead. */ dataSourceVariant: "unpublished"; /** * When true, redirects are not evaluated for the route matching; the result will be either a composition or not found. * Note: this is always true when state=63 (internal RSC editor state) to allow contextual editing of compositions * that have redirects configured on their paths. */ ignoreRedirects: boolean; }; requestBodies: never; headers: never; pathItems: never; } type Components = components$d['schemas']; type SharedComponents$1 = components$q['schemas']; type Api = paths$c['/api/v1/canvas']; type HistoryApi = paths$b['/api/v1/canvas-history']; /** Query parameter options for GET /api/v1/canvas */ type CompositionGetParameters = Omit & { type?: string | string[]; }; /** The GET response from /api/v1/canvas when `component` or `slug` params are specified */ type CompositionGetResponse = Components['CompositionApiResponse']; /** The GET response from /api/v1/canvas-history (history for one composition) */ type ComponentInstanceHistoryGetParameters = HistoryApi['get']['parameters']['query']; /** The GET response from /api/v1/canvas-history */ type ComponentInstanceHistoryGetResponse = SharedComponents$1['HistoryApiResponse']; /** A historical version of a composition */ type ComponentInstanceHistoryEntry = SharedComponents$1['HistoryEntry']; /** @deprecated - internal use, do not rely on this value */ type CompositionUIStatus = NonNullable; /** The GET response from /api/v1/canvas when `component` or `slug` are not specified */ type CompositionGetListResponse = Components['CompositionListResponse']; /** The PUT request body for /api/v1/canvas */ type CompositionPutParameters = Api['put']['requestBody']['content']['application/json']; /** Shape of the DELETE request body for /api/v1/canvas */ type CompositionDeleteParameters = Api['delete']['requestBody']['content']['application/json']; /** Defines an editable parameter on a component. */ type ComponentParameter = Omit & { /** The value of the parameter */ value?: TValue; /** The value of the localizable parameter */ locales?: Record; /** The conditions for the parameter */ conditions?: ComponentParameterConditionalValue[]; /** The conditions for the localizable parameter */ localesConditions?: Record[]>; }; /** Parameter which stores blocks of entry types */ type ComponentParameterBlock = Omit, 'type'> & { type: typeof CANVAS_BLOCK_PARAM_TYPE; }; /** Value type of a block parameter or block field */ type BlockValue = EntryData[]; /** Value type of contextual editing parameter used with RSC CANVAS_EDITOR_STATE */ type ContextualEditingValue = { /** Names of parameters on the component which are editable */ editableParameters: string[]; }; /** The type of the parameters in contextual editing mode. */ type ComponentParameterContextualEditing = ComponentParameter & { /** Data used for visual editing. It's not supposed to be used externally. The format might change without prior notice. */ _contextualEditing?: { isEditable?: boolean | undefined; }; }; /** The type of the component instance in contextual editing mode. */ type ComponentInstanceContextualEditing = ComponentInstance & { /** Data used for visual editing. It's not supposed to be used externally. The format might change without prior notice. */ _contextualEditing?: { isEditable?: boolean | undefined; }; }; /** Defines a connection to a dynamic token on a data resource. */ type DataElementConnectionDefinition = SharedComponents$1['DataElementConnectionDefinition']; /** * The action to take if the dynamic token cannot be resolved * - t: TOKEN: Removes the failed dynamic token value, leaving the rest of the property value, if any, intact [default] * NOTE: if the _only_ value in the property is a dynamic token, the property value is removed (as with 'p' below) * NOTE: if the _failureDefault_ property is also set, that default value will be used instead of removing the token. this only applies when the failureAction is 't' or undefined, the default is otherwise ignored. * - p: PROPERTY: Removes the entire property value, including any other dynamic tokens or static values in the property * - c: COMPONENT: Removes the whole parent component or block that contains the property. * NOTE: If a 'component' failure occurs on the root component of a composition, or on an entry, it is treated as an 'a' failure because removing the root means we must remove all. * - a: ALL: Fails the whole entry or composition. This will result in the item returning a 404 from APIs, and being removed from API list responses. */ type DataElementConnectionFailureAction = SharedComponents$1['DataElementConnectionDefinition']['failureAction']; /** * How to report when the dynamic token cannot be resolved * - e: ERROR: Report an error message (this will prevent publishing) * - w: WARNING: Report a warning message [default] * - i: INFO: Report an info message (failure is expected/normal, i.e. optional data) */ type DataElementConnectionFailureLogLevel = SharedComponents$1['DataElementConnectionDefinition']['failureLogLevel']; /** Variable values for a data resource. */ type DataResourceVariables = SharedComponents$1['DataResourceVariables']; /** * Data definitions attached to this component. The property name is the key of the data in the data document. * Note: data definitions are inherited from ancestors at runtime (and may be overridden by descendants that use the same key). */ type DataResourceDefinitions = SharedComponents$1['DataResourceDefinitions']; /** Defines a data resource, which is a named JSON document, usually from an API response, which may be projected onto parameters */ type DataResourceDefinition = SharedComponents$1['DataResourceDefinition']; /** Defines the shape of a component instance served by the composition API. */ type ComponentInstance = SharedComponents$1['ComponentInstance'] & { /** Data for the component instance, provided by a component enhancer. Never set in unenhanced data. */ data?: Record; }; /** Defines the shape of the root component in a composition */ type RootComponentInstance = SharedComponents$1['RootComponentInstance']; /** * Defines the shape of a component override */ type OverrideOptions = SharedComponents$1['OverrideOptions']; /** * Defines the shape of a component override */ type ComponentOverride = SharedComponents$1['ComponentOverride']; /** * Defines a set of component overrides by component ID */ type ComponentOverrides = Record; /** Format of a copied subtree of a composition that can be pasted elsewhere */ type CopiedComponentSubtree = { componentData: ComponentInstance; overrides?: ComponentOverrides; /** Whether to paste the componentData as a block or a component (in a slot). When unspecified, 'component' is implied. */ pasteAs?: 'component' | 'block'; format: 'uniform/copied-component-subtree-1.0'; }; /** * Defines how a component on a pattern may have its values overridden */ type ComponentOverridability = SharedComponents$1['ComponentOverridability']; /** * Defines the shape of serialized webhook */ type WebhookDefinition = { endpoint: EndpointOut; headers: EndpointHeadersOut | null; transformation: EndpointTransformationOut | null; }; /** Defines single structure to keep all canvas models (used in CLI commands and Starter content generations) */ type CanvasDefinitions = { components?: Array; compositions?: Array; componentPatterns?: Array; compositionPatterns?: Array; dataTypes?: Array; categories?: Array; contentTypes?: Array; entries?: Array; entryPatterns?: Array; prompts?: Array; labels?: Array