cadenya 0.16.0

package/resources/documents.d.mts

@@ -0,0 +1,968 @@
+import { APIResource } from "../core/resource.mjs";
+import * as DocumentsAPI from "./documents.mjs";
+import * as Shared from "./shared.mjs";
+import { APIPromise } from "../core/api-promise.mjs";
+import { CursorPagination, type CursorPaginationParams, PagePromise } from "../core/pagination.mjs";
+import { RequestOptions } from "../internal/request-options.mjs";
+export declare class Documents extends APIResource {
+    /**
+     * Creates a new document in the workspace within a namespace
+     */
+    create(body: DocumentCreateParams, options?: RequestOptions): APIPromise<Document>;
+    /**
+     * Retrieves a document by ID from the workspace
+     */
+    retrieve(id: string, options?: RequestOptions): APIPromise<Document>;
+    /**
+     * Updates a document in the workspace
+     */
+    update(pathID: string, body: DocumentUpdateParams, options?: RequestOptions): APIPromise<Document>;
+    /**
+     * Lists all documents in the workspace, optionally filtered by namespace
+     */
+    list(query?: DocumentListParams | null | undefined, options?: RequestOptions): PagePromise<DocumentsCursorPagination, Document>;
+    /**
+     * Deletes a document from the workspace
+     */
+    delete(id: string, options?: RequestOptions): APIPromise<void>;
+}
+export type DocumentsCursorPagination = CursorPagination<Document>;
+export interface Any {
+    /**
+     * Contains an arbitrary serialized message along with a @type that describes the
+     * type of the serialized message.
+     */
+    value?: GoogleProtobufAny;
+    yaml?: string;
+}
+export interface AnyOrExpression {
+    any?: Any;
+    expression?: Expression;
+}
+export interface CallbacksOrReferences {
+    additionalProperties?: Array<unknown>;
+}
+export interface Document {
+    /**
+     * Holds a set of reusable objects for different aspects of the OAS. All objects
+     * defined within the components object will have no effect on the API unless they
+     * are explicitly referenced from properties outside the components object.
+     */
+    components?: Document.Components;
+    /**
+     * Allows referencing an external resource for extended documentation.
+     */
+    externalDocs?: Document.ExternalDocs;
+    /**
+     * The object provides metadata about the API. The metadata MAY be used by the
+     * clients if needed, and MAY be presented in editing or documentation generation
+     * tools for convenience.
+     */
+    info?: Document.Info;
+    openapi?: string;
+    /**
+     * Holds the relative paths to the individual endpoints and their operations. The
+     * path is appended to the URL from the `Server Object` in order to construct the
+     * full URL. The Paths MAY be empty, due to ACL constraints.
+     */
+    paths?: Document.Paths;
+    security?: Array<Document.Security>;
+    servers?: Array<Server>;
+    specificationExtension?: Array<NamedAny>;
+    tags?: Array<Document.Tag>;
+}
+export declare namespace Document {
+    /**
+     * Holds a set of reusable objects for different aspects of the OAS. All objects
+     * defined within the components object will have no effect on the API unless they
+     * are explicitly referenced from properties outside the components object.
+     */
+    interface Components {
+        callbacks?: DocumentsAPI.CallbacksOrReferences;
+        examples?: Components.Examples;
+        headers?: DocumentsAPI.HeadersOrReferences;
+        links?: Components.Links;
+        parameters?: Components.Parameters;
+        requestBodies?: Components.RequestBodies;
+        responses?: Components.Responses;
+        schemas?: Components.Schemas;
+        securitySchemes?: Components.SecuritySchemes;
+        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+    }
+    namespace Components {
+        interface Examples {
+            additionalProperties?: Array<Examples.AdditionalProperty>;
+        }
+        namespace Examples {
+            /**
+             * Automatically-generated message used to represent maps of ExampleOrReference as
+             * ordered (name,value) pairs.
+             */
+            interface AdditionalProperty {
+                /**
+                 * Map key
+                 */
+                name?: string;
+                /**
+                 * Mapped value
+                 */
+                value?: AdditionalProperty.Value;
+            }
+            namespace AdditionalProperty {
+                /**
+                 * Mapped value
+                 */
+                interface Value {
+                    example?: Value.Example;
+                    /**
+                     * A simple object to allow referencing other components in the specification,
+                     * internally and externally. The Reference Object is defined by JSON Reference and
+                     * follows the same structure, behavior and rules. For this specification,
+                     * reference resolution is accomplished as defined by the JSON Reference
+                     * specification and not by the JSON Schema specification.
+                     */
+                    reference?: DocumentsAPI.Reference;
+                }
+                namespace Value {
+                    interface Example {
+                        description?: string;
+                        externalValue?: string;
+                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                        summary?: string;
+                        value?: DocumentsAPI.Any;
+                    }
+                }
+            }
+        }
+        interface Links {
+            additionalProperties?: Array<Links.AdditionalProperty>;
+        }
+        namespace Links {
+            /**
+             * Automatically-generated message used to represent maps of LinkOrReference as
+             * ordered (name,value) pairs.
+             */
+            interface AdditionalProperty {
+                /**
+                 * Map key
+                 */
+                name?: string;
+                /**
+                 * Mapped value
+                 */
+                value?: AdditionalProperty.Value;
+            }
+            namespace AdditionalProperty {
+                /**
+                 * Mapped value
+                 */
+                interface Value {
+                    /**
+                     * The `Link object` represents a possible design-time link for a response. The
+                     * presence of a link does not guarantee the caller's ability to successfully
+                     * invoke it, rather it provides a known relationship and traversal mechanism
+                     * between responses and other operations. Unlike _dynamic_ links (i.e. links
+                     * provided **in** the response payload), the OAS linking mechanism does not
+                     * require link information in the runtime response. For computing links, and
+                     * providing instructions to execute them, a runtime expression is used for
+                     * accessing values in an operation and using them as parameters while invoking the
+                     * linked operation.
+                     */
+                    link?: Value.Link;
+                    /**
+                     * A simple object to allow referencing other components in the specification,
+                     * internally and externally. The Reference Object is defined by JSON Reference and
+                     * follows the same structure, behavior and rules. For this specification,
+                     * reference resolution is accomplished as defined by the JSON Reference
+                     * specification and not by the JSON Schema specification.
+                     */
+                    reference?: DocumentsAPI.Reference;
+                }
+                namespace Value {
+                    /**
+                     * The `Link object` represents a possible design-time link for a response. The
+                     * presence of a link does not guarantee the caller's ability to successfully
+                     * invoke it, rather it provides a known relationship and traversal mechanism
+                     * between responses and other operations. Unlike _dynamic_ links (i.e. links
+                     * provided **in** the response payload), the OAS linking mechanism does not
+                     * require link information in the runtime response. For computing links, and
+                     * providing instructions to execute them, a runtime expression is used for
+                     * accessing values in an operation and using them as parameters while invoking the
+                     * linked operation.
+                     */
+                    interface Link {
+                        description?: string;
+                        operationId?: string;
+                        operationRef?: string;
+                        parameters?: DocumentsAPI.AnyOrExpression;
+                        requestBody?: DocumentsAPI.AnyOrExpression;
+                        /**
+                         * An object representing a Server.
+                         */
+                        server?: DocumentsAPI.Server;
+                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                    }
+                }
+            }
+        }
+        interface Parameters {
+            additionalProperties?: Array<Parameters.AdditionalProperty>;
+        }
+        namespace Parameters {
+            /**
+             * Automatically-generated message used to represent maps of ParameterOrReference
+             * as ordered (name,value) pairs.
+             */
+            interface AdditionalProperty {
+                /**
+                 * Map key
+                 */
+                name?: string;
+                /**
+                 * Mapped value
+                 */
+                value?: AdditionalProperty.Value;
+            }
+            namespace AdditionalProperty {
+                /**
+                 * Mapped value
+                 */
+                interface Value {
+                    /**
+                     * Describes a single operation parameter. A unique parameter is defined by a
+                     * combination of a name and location.
+                     */
+                    parameter?: Value.Parameter;
+                    /**
+                     * A simple object to allow referencing other components in the specification,
+                     * internally and externally. The Reference Object is defined by JSON Reference and
+                     * follows the same structure, behavior and rules. For this specification,
+                     * reference resolution is accomplished as defined by the JSON Reference
+                     * specification and not by the JSON Schema specification.
+                     */
+                    reference?: DocumentsAPI.Reference;
+                }
+                namespace Value {
+                    /**
+                     * Describes a single operation parameter. A unique parameter is defined by a
+                     * combination of a name and location.
+                     */
+                    interface Parameter {
+                        allowEmptyValue?: boolean;
+                        allowReserved?: boolean;
+                        content?: DocumentsAPI.MediaTypes;
+                        deprecated?: boolean;
+                        description?: string;
+                        example?: DocumentsAPI.Any;
+                        examples?: Parameter.Examples;
+                        explode?: boolean;
+                        in?: string;
+                        name?: string;
+                        required?: boolean;
+                        schema?: DocumentsAPI.SchemaOrReference;
+                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                        style?: string;
+                    }
+                    namespace Parameter {
+                        interface Examples {
+                            additionalProperties?: Array<Examples.AdditionalProperty>;
+                        }
+                        namespace Examples {
+                            /**
+                             * Automatically-generated message used to represent maps of ExampleOrReference as
+                             * ordered (name,value) pairs.
+                             */
+                            interface AdditionalProperty {
+                                /**
+                                 * Map key
+                                 */
+                                name?: string;
+                                /**
+                                 * Mapped value
+                                 */
+                                value?: AdditionalProperty.Value;
+                            }
+                            namespace AdditionalProperty {
+                                /**
+                                 * Mapped value
+                                 */
+                                interface Value {
+                                    example?: Value.Example;
+                                    /**
+                                     * A simple object to allow referencing other components in the specification,
+                                     * internally and externally. The Reference Object is defined by JSON Reference and
+                                     * follows the same structure, behavior and rules. For this specification,
+                                     * reference resolution is accomplished as defined by the JSON Reference
+                                     * specification and not by the JSON Schema specification.
+                                     */
+                                    reference?: DocumentsAPI.Reference;
+                                }
+                                namespace Value {
+                                    interface Example {
+                                        description?: string;
+                                        externalValue?: string;
+                                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                                        summary?: string;
+                                        value?: DocumentsAPI.Any;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        interface RequestBodies {
+            additionalProperties?: Array<RequestBodies.AdditionalProperty>;
+        }
+        namespace RequestBodies {
+            /**
+             * Automatically-generated message used to represent maps of RequestBodyOrReference
+             * as ordered (name,value) pairs.
+             */
+            interface AdditionalProperty {
+                /**
+                 * Map key
+                 */
+                name?: string;
+                /**
+                 * Mapped value
+                 */
+                value?: AdditionalProperty.Value;
+            }
+            namespace AdditionalProperty {
+                /**
+                 * Mapped value
+                 */
+                interface Value {
+                    /**
+                     * A simple object to allow referencing other components in the specification,
+                     * internally and externally. The Reference Object is defined by JSON Reference and
+                     * follows the same structure, behavior and rules. For this specification,
+                     * reference resolution is accomplished as defined by the JSON Reference
+                     * specification and not by the JSON Schema specification.
+                     */
+                    reference?: DocumentsAPI.Reference;
+                    /**
+                     * Describes a single request body.
+                     */
+                    requestBody?: Value.RequestBody;
+                }
+                namespace Value {
+                    /**
+                     * Describes a single request body.
+                     */
+                    interface RequestBody {
+                        content?: DocumentsAPI.MediaTypes;
+                        description?: string;
+                        required?: boolean;
+                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                    }
+                }
+            }
+        }
+        interface Responses {
+            additionalProperties?: Array<Responses.AdditionalProperty>;
+        }
+        namespace Responses {
+            /**
+             * Automatically-generated message used to represent maps of ResponseOrReference as
+             * ordered (name,value) pairs.
+             */
+            interface AdditionalProperty {
+                /**
+                 * Map key
+                 */
+                name?: string;
+                /**
+                 * Mapped value
+                 */
+                value?: AdditionalProperty.Value;
+            }
+            namespace AdditionalProperty {
+                /**
+                 * Mapped value
+                 */
+                interface Value {
+                    /**
+                     * A simple object to allow referencing other components in the specification,
+                     * internally and externally. The Reference Object is defined by JSON Reference and
+                     * follows the same structure, behavior and rules. For this specification,
+                     * reference resolution is accomplished as defined by the JSON Reference
+                     * specification and not by the JSON Schema specification.
+                     */
+                    reference?: DocumentsAPI.Reference;
+                    /**
+                     * Describes a single response from an API Operation, including design-time, static
+                     * `links` to operations based on the response.
+                     */
+                    response?: Value.Response;
+                }
+                namespace Value {
+                    /**
+                     * Describes a single response from an API Operation, including design-time, static
+                     * `links` to operations based on the response.
+                     */
+                    interface Response {
+                        content?: DocumentsAPI.MediaTypes;
+                        description?: string;
+                        headers?: DocumentsAPI.HeadersOrReferences;
+                        links?: Response.Links;
+                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                    }
+                    namespace Response {
+                        interface Links {
+                            additionalProperties?: Array<Links.AdditionalProperty>;
+                        }
+                        namespace Links {
+                            /**
+                             * Automatically-generated message used to represent maps of LinkOrReference as
+                             * ordered (name,value) pairs.
+                             */
+                            interface AdditionalProperty {
+                                /**
+                                 * Map key
+                                 */
+                                name?: string;
+                                /**
+                                 * Mapped value
+                                 */
+                                value?: AdditionalProperty.Value;
+                            }
+                            namespace AdditionalProperty {
+                                /**
+                                 * Mapped value
+                                 */
+                                interface Value {
+                                    /**
+                                     * The `Link object` represents a possible design-time link for a response. The
+                                     * presence of a link does not guarantee the caller's ability to successfully
+                                     * invoke it, rather it provides a known relationship and traversal mechanism
+                                     * between responses and other operations. Unlike _dynamic_ links (i.e. links
+                                     * provided **in** the response payload), the OAS linking mechanism does not
+                                     * require link information in the runtime response. For computing links, and
+                                     * providing instructions to execute them, a runtime expression is used for
+                                     * accessing values in an operation and using them as parameters while invoking the
+                                     * linked operation.
+                                     */
+                                    link?: Value.Link;
+                                    /**
+                                     * A simple object to allow referencing other components in the specification,
+                                     * internally and externally. The Reference Object is defined by JSON Reference and
+                                     * follows the same structure, behavior and rules. For this specification,
+                                     * reference resolution is accomplished as defined by the JSON Reference
+                                     * specification and not by the JSON Schema specification.
+                                     */
+                                    reference?: DocumentsAPI.Reference;
+                                }
+                                namespace Value {
+                                    /**
+                                     * The `Link object` represents a possible design-time link for a response. The
+                                     * presence of a link does not guarantee the caller's ability to successfully
+                                     * invoke it, rather it provides a known relationship and traversal mechanism
+                                     * between responses and other operations. Unlike _dynamic_ links (i.e. links
+                                     * provided **in** the response payload), the OAS linking mechanism does not
+                                     * require link information in the runtime response. For computing links, and
+                                     * providing instructions to execute them, a runtime expression is used for
+                                     * accessing values in an operation and using them as parameters while invoking the
+                                     * linked operation.
+                                     */
+                                    interface Link {
+                                        description?: string;
+                                        operationId?: string;
+                                        operationRef?: string;
+                                        parameters?: DocumentsAPI.AnyOrExpression;
+                                        requestBody?: DocumentsAPI.AnyOrExpression;
+                                        /**
+                                         * An object representing a Server.
+                                         */
+                                        server?: DocumentsAPI.Server;
+                                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        interface Schemas {
+            additionalProperties?: Array<DocumentsAPI.NamedSchemaOrReference>;
+        }
+        interface SecuritySchemes {
+            additionalProperties?: Array<SecuritySchemes.AdditionalProperty>;
+        }
+        namespace SecuritySchemes {
+            /**
+             * Automatically-generated message used to represent maps of
+             * SecuritySchemeOrReference as ordered (name,value) pairs.
+             */
+            interface AdditionalProperty {
+                /**
+                 * Map key
+                 */
+                name?: string;
+                /**
+                 * Mapped value
+                 */
+                value?: AdditionalProperty.Value;
+            }
+            namespace AdditionalProperty {
+                /**
+                 * Mapped value
+                 */
+                interface Value {
+                    /**
+                     * A simple object to allow referencing other components in the specification,
+                     * internally and externally. The Reference Object is defined by JSON Reference and
+                     * follows the same structure, behavior and rules. For this specification,
+                     * reference resolution is accomplished as defined by the JSON Reference
+                     * specification and not by the JSON Schema specification.
+                     */
+                    reference?: DocumentsAPI.Reference;
+                    /**
+                     * Defines a security scheme that can be used by the operations. Supported schemes
+                     * are HTTP authentication, an API key (either as a header, a cookie parameter or
+                     * as a query parameter), mutual TLS (use of a client certificate), OAuth2's common
+                     * flows (implicit, password, application and access code) as defined in RFC6749,
+                     * and OpenID Connect. Please note that currently (2019) the implicit flow is about
+                     * to be deprecated OAuth 2.0 Security Best Current Practice. Recommended for most
+                     * use case is Authorization Code Grant flow with PKCE.
+                     */
+                    securityScheme?: Value.SecurityScheme;
+                }
+                namespace Value {
+                    /**
+                     * Defines a security scheme that can be used by the operations. Supported schemes
+                     * are HTTP authentication, an API key (either as a header, a cookie parameter or
+                     * as a query parameter), mutual TLS (use of a client certificate), OAuth2's common
+                     * flows (implicit, password, application and access code) as defined in RFC6749,
+                     * and OpenID Connect. Please note that currently (2019) the implicit flow is about
+                     * to be deprecated OAuth 2.0 Security Best Current Practice. Recommended for most
+                     * use case is Authorization Code Grant flow with PKCE.
+                     */
+                    interface SecurityScheme {
+                        bearerFormat?: string;
+                        description?: string;
+                        /**
+                         * Allows configuration of the supported OAuth Flows.
+                         */
+                        flows?: SecurityScheme.Flows;
+                        in?: string;
+                        name?: string;
+                        openIdConnectUrl?: string;
+                        scheme?: string;
+                        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                        type?: string;
+                    }
+                    namespace SecurityScheme {
+                        /**
+                         * Allows configuration of the supported OAuth Flows.
+                         */
+                        interface Flows {
+                            /**
+                             * Configuration details for a supported OAuth Flow
+                             */
+                            authorizationCode?: DocumentsAPI.OAuthFlow;
+                            /**
+                             * Configuration details for a supported OAuth Flow
+                             */
+                            clientCredentials?: DocumentsAPI.OAuthFlow;
+                            /**
+                             * Configuration details for a supported OAuth Flow
+                             */
+                            implicit?: DocumentsAPI.OAuthFlow;
+                            /**
+                             * Configuration details for a supported OAuth Flow
+                             */
+                            password?: DocumentsAPI.OAuthFlow;
+                            specificationExtension?: Array<DocumentsAPI.NamedAny>;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Allows referencing an external resource for extended documentation.
+     */
+    interface ExternalDocs {
+        description?: string;
+        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+        url?: string;
+    }
+    /**
+     * The object provides metadata about the API. The metadata MAY be used by the
+     * clients if needed, and MAY be presented in editing or documentation generation
+     * tools for convenience.
+     */
+    interface Info {
+        /**
+         * Contact information for the exposed API.
+         */
+        contact?: Info.Contact;
+        description?: string;
+        /**
+         * License information for the exposed API.
+         */
+        license?: Info.License;
+        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+        summary?: string;
+        termsOfService?: string;
+        title?: string;
+        version?: string;
+    }
+    namespace Info {
+        /**
+         * Contact information for the exposed API.
+         */
+        interface Contact {
+            email?: string;
+            name?: string;
+            specificationExtension?: Array<DocumentsAPI.NamedAny>;
+            url?: string;
+        }
+        /**
+         * License information for the exposed API.
+         */
+        interface License {
+            name?: string;
+            specificationExtension?: Array<DocumentsAPI.NamedAny>;
+            url?: string;
+        }
+    }
+    /**
+     * Holds the relative paths to the individual endpoints and their operations. The
+     * path is appended to the URL from the `Server Object` in order to construct the
+     * full URL. The Paths MAY be empty, due to ACL constraints.
+     */
+    interface Paths {
+        path?: Array<DocumentsAPI.NamedPathItem>;
+        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+    }
+    /**
+     * Lists the required security schemes to execute this operation. The name used for
+     * each property MUST correspond to a security scheme declared in the Security
+     * Schemes under the Components Object. Security Requirement Objects that contain
+     * multiple schemes require that all schemes MUST be satisfied for a request to be
+     * authorized. This enables support for scenarios where multiple query parameters
+     * or HTTP headers are required to convey security information. When a list of
+     * Security Requirement Objects is defined on the OpenAPI Object or Operation
+     * Object, only one of the Security Requirement Objects in the list needs to be
+     * satisfied to authorize the request.
+     */
+    interface Security {
+        additionalProperties?: Array<Security.AdditionalProperty>;
+    }
+    namespace Security {
+        /**
+         * Automatically-generated message used to represent maps of StringArray as ordered
+         * (name,value) pairs.
+         */
+        interface AdditionalProperty {
+            /**
+             * Map key
+             */
+            name?: string;
+            /**
+             * Mapped value
+             */
+            value?: AdditionalProperty.Value;
+        }
+        namespace AdditionalProperty {
+            /**
+             * Mapped value
+             */
+            interface Value {
+                value?: Array<string>;
+            }
+        }
+    }
+    /**
+     * Adds metadata to a single tag that is used by the Operation Object. It is not
+     * mandatory to have a Tag Object per tag defined in the Operation Object
+     * instances.
+     */
+    interface Tag {
+        description?: string;
+        /**
+         * Allows referencing an external resource for extended documentation.
+         */
+        externalDocs?: Tag.ExternalDocs;
+        name?: string;
+        specificationExtension?: Array<DocumentsAPI.NamedAny>;
+    }
+    namespace Tag {
+        /**
+         * Allows referencing an external resource for extended documentation.
+         */
+        interface ExternalDocs {
+            description?: string;
+            specificationExtension?: Array<DocumentsAPI.NamedAny>;
+            url?: string;
+        }
+    }
+}
+/**
+ * DocumentSpec defines the content and properties of a document.
+ */
+export interface DocumentSpec {
+    /**
+     * InlineContent represents content stored directly in the document.
+     */
+    inlineContent?: DocumentSpecInlineContent;
+    /**
+     * RemoteSource represents a reference to an external document.
+     */
+    remoteSource?: DocumentSpecRemoteSource;
+    /**
+     * Status of the document
+     */
+    status?: 'DOCUMENT_STATUS_UNSPECIFIED' | 'DOCUMENT_STATUS_ENABLED' | 'DOCUMENT_STATUS_DISABLED' | 'DOCUMENT_STATUS_ARCHIVED';
+    /**
+     * Human-readable summary of what this document contains
+     */
+    summary?: string;
+    /**
+     * The type of document being stored
+     */
+    type?: 'DOCUMENT_TYPE_UNSPECIFIED' | 'DOCUMENT_TYPE_EPISODIC' | 'DOCUMENT_TYPE_SEMANTIC' | 'DOCUMENT_TYPE_PROCEDURAL';
+}
+/**
+ * InlineContent represents content stored directly in the document.
+ */
+export interface DocumentSpecInlineContent {
+    /**
+     * The actual content of the document
+     */
+    content?: string;
+    /**
+     * Length of the content in bytes (computed automatically)
+     */
+    length?: number;
+    /**
+     * MIME type of the content (e.g., "text/plain", "application/pdf")
+     */
+    mimeType?: string;
+}
+/**
+ * RemoteSource represents a reference to an external document.
+ */
+export interface DocumentSpecRemoteSource {
+    /**
+     * HTTP headers to include when fetching the remote source. Useful for
+     * authentication, content negotiation, etc.
+     */
+    headers?: {
+        [key: string]: string;
+    };
+    /**
+     * HTTP method to use when fetching the remote source (e.g., "GET", "POST").
+     * Defaults to GET if not specified.
+     */
+    method?: string;
+    /**
+     * URL pointing to the remote source
+     */
+    url?: string;
+}
+export interface Expression {
+    additionalProperties?: Array<NamedAny>;
+}
+/**
+ * Contains an arbitrary serialized message along with a @type that describes the
+ * type of the serialized message.
+ */
+export interface GoogleProtobufAny {
+    /**
+     * The type of the serialized message.
+     */
+    '@type'?: string;
+    [k: string]: unknown;
+}
+export interface HeadersOrReferences {
+    additionalProperties?: Array<unknown>;
+}
+export interface MediaTypes {
+    additionalProperties?: Array<unknown>;
+}
+/**
+ * Automatically-generated message used to represent maps of Any as ordered
+ * (name,value) pairs.
+ */
+export interface NamedAny {
+    /**
+     * Map key
+     */
+    name?: string;
+    /**
+     * Mapped value
+     */
+    value?: Any;
+}
+/**
+ * Automatically-generated message used to represent maps of PathItem as ordered
+ * (name,value) pairs.
+ */
+export interface NamedPathItem {
+    /**
+     * Map key
+     */
+    name?: string;
+    /**
+     * Describes the operations available on a single path. A Path Item MAY be empty,
+     * due to ACL constraints. The path itself is still exposed to the documentation
+     * viewer but they will not know which operations and parameters are available.
+     */
+    value?: unknown;
+}
+/**
+ * Automatically-generated message used to represent maps of SchemaOrReference as
+ * ordered (name,value) pairs.
+ */
+export interface NamedSchemaOrReference {
+    /**
+     * Map key
+     */
+    name?: string;
+    /**
+     * Mapped value
+     */
+    value?: SchemaOrReference;
+}
+/**
+ * Automatically-generated message used to represent maps of ServerVariable as
+ * ordered (name,value) pairs.
+ */
+export interface NamedServerVariable {
+    /**
+     * Map key
+     */
+    name?: string;
+    /**
+     * An object representing a Server Variable for server URL template substitution.
+     */
+    value?: ServerVariable;
+}
+/**
+ * Automatically-generated message used to represent maps of string as ordered
+ * (name,value) pairs.
+ */
+export interface NamedString {
+    /**
+     * Map key
+     */
+    name?: string;
+    /**
+     * Mapped value
+     */
+    value?: string;
+}
+/**
+ * Configuration details for a supported OAuth Flow
+ */
+export interface OAuthFlow {
+    authorizationUrl?: string;
+    refreshUrl?: string;
+    scopes?: Strings;
+    specificationExtension?: Array<NamedAny>;
+    tokenUrl?: string;
+}
+/**
+ * A simple object to allow referencing other components in the specification,
+ * internally and externally. The Reference Object is defined by JSON Reference and
+ * follows the same structure, behavior and rules. For this specification,
+ * reference resolution is accomplished as defined by the JSON Reference
+ * specification and not by the JSON Schema specification.
+ */
+export interface Reference {
+    description?: string;
+    Ref?: string;
+    summary?: string;
+}
+export interface SchemaOrReference {
+    /**
+     * A simple object to allow referencing other components in the specification,
+     * internally and externally. The Reference Object is defined by JSON Reference and
+     * follows the same structure, behavior and rules. For this specification,
+     * reference resolution is accomplished as defined by the JSON Reference
+     * specification and not by the JSON Schema specification.
+     */
+    reference?: Reference;
+    /**
+     * The Schema Object allows the definition of input and output data types. These
+     * types can be objects, but also primitives and arrays. This object is an extended
+     * subset of the JSON Schema Specification Wright Draft 00. For more information
+     * about the properties, see JSON Schema Core and JSON Schema Validation. Unless
+     * stated otherwise, the property definitions follow the JSON Schema.
+     */
+    schema?: unknown;
+}
+/**
+ * An object representing a Server.
+ */
+export interface Server {
+    description?: string;
+    specificationExtension?: Array<NamedAny>;
+    url?: string;
+    variables?: ServerVariables;
+}
+/**
+ * An object representing a Server Variable for server URL template substitution.
+ */
+export interface ServerVariable {
+    default?: string;
+    description?: string;
+    enum?: Array<string>;
+    specificationExtension?: Array<NamedAny>;
+}
+export interface ServerVariables {
+    additionalProperties?: Array<NamedServerVariable>;
+}
+export interface Strings {
+    additionalProperties?: Array<NamedString>;
+}
+export interface DocumentCreateParams {
+    /**
+     * Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+     */
+    metadata?: Shared.ResourceMetadata;
+    /**
+     * The namespace this document belongs to. Each document belongs to exactly one
+     * namespace.
+     */
+    namespaceId?: string;
+    /**
+     * DocumentSpec defines the content and properties of a document.
+     */
+    spec?: DocumentSpec;
+}
+export interface DocumentUpdateParams {
+    /**
+     * Unique identifier of the document to update
+     */
+    body_id?: string;
+    /**
+     * Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+     */
+    metadata?: Shared.ResourceMetadata;
+    /**
+     * DocumentSpec defines the content and properties of a document.
+     */
+    spec?: DocumentSpec;
+    /**
+     * Fields to update (if empty, all fields are updated)
+     */
+    updateMask?: string;
+}
+export interface DocumentListParams extends CursorPaginationParams {
+    /**
+     * Optional: Filter documents by namespace ID. If provided, only returns documents
+     * that belong to this namespace.
+     */
+    namespaceId?: string;
+}
+export declare namespace Documents {
+    export { type Any as Any, type AnyOrExpression as AnyOrExpression, type CallbacksOrReferences as CallbacksOrReferences, type Document as Document, type DocumentSpec as DocumentSpec, type DocumentSpecInlineContent as DocumentSpecInlineContent, type DocumentSpecRemoteSource as DocumentSpecRemoteSource, type Expression as Expression, type GoogleProtobufAny as GoogleProtobufAny, type HeadersOrReferences as HeadersOrReferences, type MediaTypes as MediaTypes, type NamedAny as NamedAny, type NamedPathItem as NamedPathItem, type NamedSchemaOrReference as NamedSchemaOrReference, type NamedServerVariable as NamedServerVariable, type NamedString as NamedString, type OAuthFlow as OAuthFlow, type Reference as Reference, type SchemaOrReference as SchemaOrReference, type Server as Server, type ServerVariable as ServerVariable, type ServerVariables as ServerVariables, type Strings as Strings, type DocumentsCursorPagination as DocumentsCursorPagination, type DocumentCreateParams as DocumentCreateParams, type DocumentUpdateParams as DocumentUpdateParams, type DocumentListParams as DocumentListParams, };
+}
+//# sourceMappingURL=documents.d.mts.map