@wildo-ai/external-connectors-models 1.1.1 → 1.1.3

package/dist/esm/protocols/rest-operations.external-connectors-models.schemas.js

@@ -0,0 +1,89 @@
+/**
+ * The REST OPERATION vocabulary — what an operation IS, independent of who executes one.
+ *
+ * Moved here from `@wildo-ai/external-connectors-private/backend` on 2026-09-06 (#378), and the
+ * reason is a measurement rather than tidiness. A generated provider's operation catalogue is loaded
+ * LAZILY on purpose: the loader contract forbids evaluating it at boot, because a provider whose
+ * operations are eager puts every vendor's operations into every process's boot graph. But the
+ * catalogue module needs `ProviderRestParameterLocation` and `ProviderRestRequestBodyEncoding` as
+ * VALUES, and their only public door was the backend barrel — so reading two string enums pulled the
+ * entire backend provider surface in behind them:
+ *
+ * | import | heap | time |
+ * |---|---|---|
+ * | `@wildo-ai/external-connectors-models` | 20.8 MB | 39 ms |
+ * | `@wildo-ai/external-connectors-private/backend` | 160.7 MB | 251 ms |
+ *
+ * 161 MB to answer "is this parameter in the path or the query". The vocabulary belongs here for a
+ * reason that survives the measurement, too: it describes what an operation IS — its method, its
+ * path template, where its parameters ride — and none of that is backend runtime. The arrow already
+ * pointed this way, since this package has no dependency on the private backend and the private
+ * backend depends on it.
+ */
+/** Where a declared parameter rides on the wire. */
+export var ProviderRestParameterLocation;
+(function (ProviderRestParameterLocation) {
+    /** Substituted into a `{token}` of the path template. Always required — a path cannot have a hole. */
+    ProviderRestParameterLocation["PATH"] = "path";
+    ProviderRestParameterLocation["QUERY"] = "query";
+    ProviderRestParameterLocation["HEADER"] = "header";
+})(ProviderRestParameterLocation || (ProviderRestParameterLocation = {}));
+/**
+ * How the request body is encoded. The ETL read surface only ever needed JSON; a hand-authored
+ * write reaches vendors that take form bodies (OAuth-adjacent endpoints, older CRMs) and file
+ * uploads, so the encoding is DECLARED per operation rather than inferred from the method.
+ */
+export var ProviderRestRequestBodyEncoding;
+(function (ProviderRestRequestBodyEncoding) {
+    ProviderRestRequestBodyEncoding["JSON"] = "json";
+    ProviderRestRequestBodyEncoding["FORM_URLENCODED"] = "form-urlencoded";
+    ProviderRestRequestBodyEncoding["MULTIPART"] = "multipart";
+    /** A raw text body; `contentType` on the declaration says which media type is sent. */
+    ProviderRestRequestBodyEncoding["TEXT"] = "text";
+})(ProviderRestRequestBodyEncoding || (ProviderRestRequestBodyEncoding = {}));
+/**
+ * How a listing operation continues. A HINT the caller reads, never something the executor acts
+ * on: an executor that paged on its own would decide a caller's memory budget for it, and the
+ * ETL lane already owns paging as a discipline (drift-safe continuation only).
+ */
+export var ProviderRestPaginationStyle;
+(function (ProviderRestPaginationStyle) {
+    ProviderRestPaginationStyle["OFFSET"] = "offset";
+    ProviderRestPaginationStyle["PAGE"] = "page";
+    ProviderRestPaginationStyle["CURSOR"] = "cursor";
+    /** The vendor returns its own continuation URL (`@odata.nextLink`, `links.next`). */
+    ProviderRestPaginationStyle["LINK"] = "link";
+})(ProviderRestPaginationStyle || (ProviderRestPaginationStyle = {}));
+/**
+ * Vendors whose credential is COMPUTED per request rather than sent as a fixed header.
+ *
+ * A static header covers bearer tokens and API keys, which is most of the world. It cannot express a
+ * signature: AWS Signature Version 4 signs the method, the canonical path, the sorted query, a
+ * subset of headers, a SHA-256 of the payload and a timestamp, with a key derived from the secret,
+ * the date, the region and the service — so the header's VALUE differs for every request and none of
+ * its inputs exist when a provider module is authored.
+ *
+ * Until this existed, such a vendor could not be expressed at all — not badly, not partially. There
+ * was no `if` to write, because the field where the answer goes did not exist. 45 transposed actions
+ * across `amazon-s3`, `amazon-ses`, `amazon-textract`, `amazon-secrets-manager`, `amazon-sqs`,
+ * `amazon-bedrock`, `azure-blob-storage`, `azure-communication-services` and `azure-openai` are
+ * blocked on it (#373).
+ */
+export var ProviderRestSigningScheme;
+(function (ProviderRestSigningScheme) {
+    /**
+     * AWS Signature Version 4 — the `Authorization: AWS4-HMAC-SHA256 …` scheme used by every current
+     * AWS service API.
+     * spec-cite: AWS General Reference, "Signature Version 4 signing process"
+     * (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv4-signing-process.html)
+     */
+    ProviderRestSigningScheme["AWS_SIGV4"] = "AWS_SIGV4";
+    /**
+     * Azure Storage shared-key — `Authorization: SharedKey <account>:<signature>` over a canonicalized
+     * request and resource.
+     * spec-cite: Azure Storage REST, "Authorize with Shared Key"
+     * (https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key)
+     */
+    ProviderRestSigningScheme["AZURE_SHARED_KEY"] = "AZURE_SHARED_KEY";
+})(ProviderRestSigningScheme || (ProviderRestSigningScheme = {}));
+//# sourceMappingURL=rest-operations.external-connectors-models.schemas.js.map

package/dist/esm/protocols/rest-operations.external-connectors-models.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-operations.external-connectors-models.schemas.js","sourceRoot":"","sources":["../../../../src/protocols/rest-operations.external-connectors-models.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,oDAAoD;AACpD,MAAM,CAAN,IAAY,6BAKX;AALD,WAAY,6BAA6B;IACvC,sGAAsG;IACtG,8CAAa,CAAA;IACb,gDAAe,CAAA;IACf,kDAAiB,CAAA;AACnB,CAAC,EALW,6BAA6B,KAA7B,6BAA6B,QAKxC;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,+BAMX;AAND,WAAY,+BAA+B;IACzC,gDAAa,CAAA;IACb,sEAAmC,CAAA;IACnC,0DAAuB,CAAA;IACvB,uFAAuF;IACvF,gDAAa,CAAA;AACf,CAAC,EANW,+BAA+B,KAA/B,+BAA+B,QAM1C;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,2BAMX;AAND,WAAY,2BAA2B;IACrC,gDAAiB,CAAA;IACjB,4CAAa,CAAA;IACb,gDAAiB,CAAA;IACjB,qFAAqF;IACrF,4CAAa,CAAA;AACf,CAAC,EANW,2BAA2B,KAA3B,2BAA2B,QAMtC;AA0OD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAN,IAAY,yBAeX;AAfD,WAAY,yBAAyB;IACnC;;;;;OAKG;IACH,oDAAuB,CAAA;IACvB;;;;;OAKG;IACH,kEAAqC,CAAA;AACvC,CAAC,EAfW,yBAAyB,KAAzB,yBAAyB,QAepC","sourcesContent":["/**\n * The REST OPERATION vocabulary — what an operation IS, independent of who executes one.\n *\n * Moved here from `@wildo-ai/external-connectors-private/backend` on 2026-09-06 (#378), and the\n * reason is a measurement rather than tidiness. A generated provider's operation catalogue is loaded\n * LAZILY on purpose: the loader contract forbids evaluating it at boot, because a provider whose\n * operations are eager puts every vendor's operations into every process's boot graph. But the\n * catalogue module needs `ProviderRestParameterLocation` and `ProviderRestRequestBodyEncoding` as\n * VALUES, and their only public door was the backend barrel — so reading two string enums pulled the\n * entire backend provider surface in behind them:\n *\n * | import | heap | time |\n * |---|---|---|\n * | `@wildo-ai/external-connectors-models` | 20.8 MB | 39 ms |\n * | `@wildo-ai/external-connectors-private/backend` | 160.7 MB | 251 ms |\n *\n * 161 MB to answer \"is this parameter in the path or the query\". The vocabulary belongs here for a\n * reason that survives the measurement, too: it describes what an operation IS — its method, its\n * path template, where its parameters ride — and none of that is backend runtime. The arrow already\n * pointed this way, since this package has no dependency on the private backend and the private\n * backend depends on it.\n */\n\nimport { z } from 'zod';\n\nimport { API_HttpMethod } from '../core/commons.external-connectors-models.schemas';\nimport { ExternalOperation_Classification } from '../core/operation-classification.external-connectors-models.schemas';\nimport type { ExternalProvider_ConnectionTarget } from '../core/security.external-connectors-models.schemas';\n\n/** Where a declared parameter rides on the wire. */\nexport enum ProviderRestParameterLocation {\n  /** Substituted into a `{token}` of the path template. Always required — a path cannot have a hole. */\n  PATH = 'path',\n  QUERY = 'query',\n  HEADER = 'header',\n}\n\n/**\n * How the request body is encoded. The ETL read surface only ever needed JSON; a hand-authored\n * write reaches vendors that take form bodies (OAuth-adjacent endpoints, older CRMs) and file\n * uploads, so the encoding is DECLARED per operation rather than inferred from the method.\n */\nexport enum ProviderRestRequestBodyEncoding {\n  JSON = 'json',\n  FORM_URLENCODED = 'form-urlencoded',\n  MULTIPART = 'multipart',\n  /** A raw text body; `contentType` on the declaration says which media type is sent. */\n  TEXT = 'text',\n}\n\n/**\n * How a listing operation continues. A HINT the caller reads, never something the executor acts\n * on: an executor that paged on its own would decide a caller's memory budget for it, and the\n * ETL lane already owns paging as a discipline (drift-safe continuation only).\n */\nexport enum ProviderRestPaginationStyle {\n  OFFSET = 'offset',\n  PAGE = 'page',\n  CURSOR = 'cursor',\n  /** The vendor returns its own continuation URL (`@odata.nextLink`, `links.next`). */\n  LINK = 'link',\n}\n\n/** One declared parameter: a wire name, where it rides, and which input field feeds it. */\nexport interface ProviderRestOperationParameter {\n  /** The name ON THE WIRE (`page_size`, `X-Vendor-Version`, or the `{token}` in the path). */\n  readonly name: string;\n  readonly in: ProviderRestParameterLocation;\n  /**\n   * The INPUT field that feeds it, when the two differ (`pageSize` → `page_size`). Absent means\n   * the input field is spelled exactly like the wire name. Declared, never camel/snake-guessed:\n   * a guess that is wrong drops a parameter silently and the vendor answers a valid-looking\n   * default page.\n   */\n  readonly from?: string;\n  /** PATH parameters are required whatever this says; for QUERY/HEADER, absent means optional. */\n  readonly required?: boolean;\n  /** A literal value sent on every call — for a version pin or a fixed format selector. */\n  readonly constantValue?: string;\n  readonly description?: string;\n}\n\n/** How the request body is built from the operation's input. */\nexport interface ProviderRestOperationRequestBody {\n  readonly encoding: ProviderRestRequestBodyEncoding;\n  /**\n   * The input field carrying the whole body. Absent = the body is every input field NOT consumed\n   * by a declared parameter — the ordinary shape, and the reason parameters declare `from`.\n   */\n  readonly from?: string;\n  /** For `TEXT`: the media type actually sent (`text/csv`, `application/xml`). */\n  readonly contentType?: string;\n}\n\n/** Where the payload sits inside a response, and how a listing continues. */\nexport interface ProviderRestOperationPagination {\n  readonly style: ProviderRestPaginationStyle;\n  /** OFFSET/PAGE/CURSOR: the request parameter names the caller advances. */\n  readonly limitParam?: string;\n  readonly offsetParam?: string;\n  readonly pageParam?: string;\n  readonly cursorParam?: string;\n  /** CURSOR/LINK: dot-path in the RESPONSE carrying the next cursor or the next URL. */\n  readonly nextPath?: string;\n}\n\n/**\n * A provider operation, hand-authored. The unit an application addresses:\n * `executeProviderOperation({ providerRef: 'slack', operationId: 'conversations.list', input })`.\n */\nexport interface ProviderRestOperation {\n  /** Unique within the provider, and the address an ETL binding reference uses. */\n  readonly operationId: string;\n  /**\n   * The lazy-load unit. `operations('conversations')` answers only this domain's operations, so a\n   * vendor with hundreds need not evaluate them all to run one.\n   */\n  readonly domain: string;\n  readonly method: API_HttpMethod;\n  /** Relative to the provider's base URL. `{token}` interpolates a PATH parameter of that name. */\n  readonly pathTemplate: string;\n  readonly summary?: string;\n  /**\n   * Whether the operation MUTATES the vendor.\n   *\n   * ONE vocabulary for every operation catalogue, whatever produced it: a hand-authored operation\n   * and a generated one are the same concept, and two enums over the same two values is precisely\n   * the drift D1 exists to remove. Read by an ETL binding reference (which refuses to serve a read\n   * surface from a WRITE), by the audit trail as the axis a reviewer filters on first, and by a UI\n   * deciding whether to confirm.\n   *\n   * The name carried a source catalogue's spelling until 2026-09-06 and no longer does — an\n   * operation's EFFECT is not a property of where its definition came from.\n   */\n  readonly classification: ExternalOperation_Classification;\n  readonly parameters?: readonly ProviderRestOperationParameter[];\n  readonly requestBody?: ProviderRestOperationRequestBody;\n  /**\n   * Zod schema the caller's input is parsed through BEFORE anything is compiled. A typed client\n   * (S3b) derives its argument type from it. Absent = the input is passed through unvalidated,\n   * which is legal for a thin wrapper and honest about carrying no contract.\n   */\n  readonly inputSchema?: z.ZodType;\n  /**\n   * Zod schema the RESPONSE is parsed through. Absent = the parsed body is returned as `unknown`.\n   * A vendor adding a field must never break a call, so authors should keep these permissive; the\n   * value is in naming the fields a caller may rely on, not in policing the vendor.\n   */\n  readonly outputSchema?: z.ZodType;\n  /** Dot-path to the payload inside the response body. Absent = the body IS the payload. */\n  readonly resultPath?: string;\n  readonly pagination?: ProviderRestOperationPagination;\n  /**\n   * OAuth scopes (or vendor permission names) the credential must carry. DECLARED in S3a and not\n   * yet CHECKED: checking it needs the composed registry's view of the secrets contract, which is\n   * #329's. Recorded as owed rather than half-enforced — a check that silently passes is worse\n   * than no check.\n   */\n  readonly requiredScopes?: readonly string[];\n  /**\n   * Whether re-sending this request is safe. Absent = derived from the method: GET, HEAD, OPTIONS,\n   * PUT and DELETE are idempotent, POST and PATCH are not.\n   * spec-cite: RFC 9110 §9.2.2 (PUT, DELETE and the safe methods are idempotent) and §9.2.1\n   * (GET, HEAD, OPTIONS, TRACE are safe).\n   * Declare it TRUE on a POST the vendor documents as idempotent (an idempotency-key endpoint);\n   * declaring it wrongly is how a retried timeout charges a customer twice.\n   */\n  readonly idempotent?: boolean;\n  /** Narrows the provider's semantics for this one operation (a slow export, a tight endpoint). */\n  readonly remoteCallSemantics?: Partial<ProviderRestCallSemantics>;\n  /** Set when the vendor has deprecated it; the executor logs once per operation, never refuses. */\n  readonly deprecated?: {\n    readonly reason: string;\n    readonly since?: string;\n    readonly replacedByOperationId?: string;\n  };\n}\n\n/** What one `operations(domain?)` call answers. */\nexport interface ProviderRestOperationCatalogue {\n  /** The domains this load carries — the whole set when called with no argument. */\n  readonly domains: readonly string[];\n  /** Keyed by `operationId`. */\n  readonly operations: Readonly<Record<string, ProviderRestOperation>>;\n}\n\n/**\n * The lazy catalogue loader — the seam #330's host loader consumes (interface note on #331).\n *\n * MUST NOT be called during composition, discovery or boot: it exists so a provider package can\n * `import()` its own operation module only when a run needs it, and calling it at boot puts every\n * provider's operations back into every process's boot graph, which is the thing on-demand\n * loading exists to remove. Async, idempotent, and memoized by the executor per\n * `(providerRef, domain)` — a loader may assume one call per pair and must stay correct on two.\n *\n * The values it returns carry live Zod schemas, so a catalogue is an IN-PROCESS value and is\n * never serializable into a runtime artifact or any JSON the CLI emits.\n */\nexport type ProviderRestOperationCatalogueLoader = (domain?: string) => Promise<ProviderRestOperationCatalogue>;\n\n/**\n * Provider-level call semantics: the defaults every operation of this provider runs under.\n *\n * Structurally the executable subset of the ETL's `HttpApiRemoteCallSemantics`, and deliberately\n * NOT that type: the ETL's lives in `@wildo-ai/saas-models/external-data` and carries\n * `maxIdSetSize`, an ETL query-translation bound that means nothing to a provider operation.\n * Importing it here would point the PROVIDER contract at the ETL read surface — backwards, since\n * the ETL references provider operations and not the reverse. Three fields is the price of\n * keeping that arrow pointing the right way.\n */\nexport interface ProviderRestCallSemantics {\n  /** Per-attempt timeout. */\n  readonly timeoutMs: number;\n  readonly retry: {\n    /** Total attempts including the first; 1 disables retry. */\n    readonly maxAttempts: number;\n    /** Linear backoff base — attempt N waits `backoffMs * (N - 1)`. */\n    readonly backoffMs: number;\n  };\n  /** A local sliding-window ceiling; the call REFUSES when exhausted rather than queueing. */\n  readonly maxRequestsPerMinute?: number;\n}\n\n\n/**\n * A provider whose credential is MINTED by an authorization-code exchange rather than pasted.\n *\n * Recorded because the source catalogues state it and nothing else does. 131 of the 699 transposed\n * vendors declare OAuth2, and their authorize URL, token URL and scopes exist nowhere in this\n * repository except the catalogue that was read — so extracting them and keeping them only in a\n * comment (which is what the transposer did until 2026-09-07) means the delegated-authorization lane\n * re-derives 131 vendors' endpoints by hand.\n *\n * ## What it does NOT change\n *\n * The wire placement. An OAuth2 access token rides in the same header as an API key —\n * `Authorization: Bearer …` — so `apiKey.headerName` and `apiKey.prefix` still describe the request,\n * and `apiKey.secretRef` still names the slot the credential is read from. What this block adds is\n * where that value COMES FROM: an exchange, per organization or per user, refreshable — rather than\n * an operator pasting a long-lived token into an environment variable.\n *\n * That distinction is the whole point. Without it a provider declares a static bearer key and, if an\n * operator happens to paste a long-lived token, WORKS — while advertising a credential model the\n * vendor does not offer, with no authorize step, no refresh and no per-tenant token. A wrong\n * configuration that works is worse than one that fails, because nothing surfaces it.\n *\n * The FLOW is not here and is not implied: connected accounts, the authorization round trip, refresh\n * and revocation are their own lane. This is the declaration that lane consumes.\n */\nexport interface ProviderRestOAuth2 {\n  /** Where the user is sent to grant access. Carries the vendor's own default scopes when it states them. */\n  readonly authorizeUrl: string;\n  /** Where an authorization code (or a refresh token) is exchanged for an access token. */\n  readonly tokenUrl: string;\n  /**\n   * Scopes the vendor's own catalogue entry asked for. Advisory rather than enforced: an application\n   * may need fewer, and an operation's `requiredScopes` is the finer statement. Kept because it is\n   * the only record of what the vendor expects for the operations transposed beside it.\n   */\n  readonly scopes?: readonly string[];\n  /**\n   * Env-var names resolving the APPLICATION's registration with the vendor. These are the two values\n   * an operator genuinely does paste — they identify the integration, not the end user — and they\n   * are separate from `apiKey.secretRef`, which names the minted access token.\n   */\n  readonly clientIdSecretRef?: string;\n  readonly clientSecretSecretRef?: string;\n  /**\n   * Placeholders the endpoints above carry, which a CONNECTION must supply before either URL is a\n   * URL at all — `{cloud}`, `{tenantId}`, `{region}`, `{domain}`.\n   *\n   * Measured over the transposed catalogue on 2026-09-08: of the 96 vendors that recovered both\n   * endpoints, **21 carry at least one placeholder**, led by `{cloud}` (18), `{location}` (10) and\n   * `{tenantId}` (6). Microsoft's authorize URL is\n   * `https://{cloud}/{tenantId}/oauth2/v2.0/authorize`, and no amount of application configuration\n   * supplies those: which Azure cloud and which directory are facts about the ACCOUNT BEING\n   * CONNECTED, known only to the person connecting it.\n   *\n   * So this is not decoration on the endpoint strings — it is the difference between a vendor that\n   * can be connected and one that cannot. Without it the flow would build\n   * `https://{cloud}/…/authorize`, send somebody to a hostname containing a brace, and fail in the\n   * browser rather than at the point where the missing input could have been asked for.\n   *\n   * DERIVED from the endpoint strings rather than authored, so a vendor whose URL gains a\n   * placeholder declares one the next time the batch runs. Absent — not empty — when the endpoints\n   * are plain, which is the common case and must stay distinguishable from \"nobody has looked\".\n   *\n   * Deliberately NOT a judgement about which connections a provider admits. That is a recorded\n   * decision in the catalogue record and is never read from a vendor's API surface; this is a\n   * mechanical fact about a string.\n   */\n  readonly connectionParameters?: readonly string[];\n}\n\n\n/**\n * Vendors whose credential is COMPUTED per request rather than sent as a fixed header.\n *\n * A static header covers bearer tokens and API keys, which is most of the world. It cannot express a\n * signature: AWS Signature Version 4 signs the method, the canonical path, the sorted query, a\n * subset of headers, a SHA-256 of the payload and a timestamp, with a key derived from the secret,\n * the date, the region and the service — so the header's VALUE differs for every request and none of\n * its inputs exist when a provider module is authored.\n *\n * Until this existed, such a vendor could not be expressed at all — not badly, not partially. There\n * was no `if` to write, because the field where the answer goes did not exist. 45 transposed actions\n * across `amazon-s3`, `amazon-ses`, `amazon-textract`, `amazon-secrets-manager`, `amazon-sqs`,\n * `amazon-bedrock`, `azure-blob-storage`, `azure-communication-services` and `azure-openai` are\n * blocked on it (#373).\n */\nexport enum ProviderRestSigningScheme {\n  /**\n   * AWS Signature Version 4 — the `Authorization: AWS4-HMAC-SHA256 …` scheme used by every current\n   * AWS service API.\n   * spec-cite: AWS General Reference, \"Signature Version 4 signing process\"\n   * (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv4-signing-process.html)\n   */\n  AWS_SIGV4 = 'AWS_SIGV4',\n  /**\n   * Azure Storage shared-key — `Authorization: SharedKey <account>:<signature>` over a canonicalized\n   * request and resource.\n   * spec-cite: Azure Storage REST, \"Authorize with Shared Key\"\n   * (https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key)\n   */\n  AZURE_SHARED_KEY = 'AZURE_SHARED_KEY',\n}\n\n/**\n * How a provider signs each request.\n *\n * Declared by the provider module and executed by the engine, with NO vendor branch in the executor:\n * the scheme is data, and the signer dispatches on it exhaustively. That is the same discipline the\n * rest of the provider contract keeps — a consumer branches on a contract field, never on a\n * provider ref.\n *\n * The credential is TWO values for both schemes (an identity and a secret), and optionally a third\n * for temporary credentials, which is why it cannot ride in the single `apiKey.secretRef` slot.\n */\nexport interface ProviderRestRequestSigning {\n  readonly scheme: ProviderRestSigningScheme;\n  /** Env-var naming the identity half — an AWS access-key id, an Azure storage account name. */\n  readonly keyIdSecretRef: string;\n  /** Env-var naming the secret half. */\n  readonly secretKeySecretRef: string;\n  /**\n   * Env-var naming a session token, for temporary credentials (STS, a role assumption). Absent means\n   * long-lived credentials; present-but-unset is treated as long-lived rather than as an error,\n   * because the same provider serves both.\n   */\n  readonly sessionTokenSecretRef?: string;\n  /**\n   * AWS_SIGV4: the region and service that scope the derived key. Both are part of the SIGNATURE,\n   * not merely of the URL, so a wrong value fails authentication rather than routing — which is why\n   * they are declared rather than parsed out of the host.\n   */\n  readonly region?: string;\n  readonly service?: string;\n  /**\n   * Env-var overriding {@link region} per deployment, for an application that runs in more than one.\n   * The declared value is the default.\n   */\n  readonly regionEnvVarName?: string;\n}\n\n/**\n * The one function a generated typed client needs, as a TYPE.\n *\n * A generated provider package must not import the engine's runtime to be callable: that would put\n * the whole backend into the module graph of anything that touches a vendor, which is precisely the\n * weight #378 removed (models 20.8 MB against the backend barrel's 160.7 MB). So a client is a\n * FACTORY that takes the executor as an argument — the application wires its own, the package\n * declares only this signature, and nothing crosses at runtime.\n *\n * R3's ergonomics bought with a type rather than a dependency.\n *\n * ## The connection is a parameter, and OPTIONAL for a reason that is not convenience\n *\n * Omitted means the application's own account, acting as itself — the floor, and the only connection\n * that needs no store and no authorization. That default is what keeps the ordinary single-account\n * call as short as it should be.\n *\n * It could not be anything BUT a parameter. One execution may legitimately spend several tenants'\n * accounts — a user action pushing a message to every organization that user belongs to — so a client\n * that read the owner from ambient state could not vary it per call, and the fan-out would be\n * inexpressible through the generated surface even though the engine beneath it supports one.\n */\nexport type ProviderOperationExecute = (\n  providerRef: string,\n  operationId: string,\n  input: Readonly<Record<string, unknown>>,\n  connection?: ExternalProvider_ConnectionTarget,\n) => Promise<unknown>;\n"]}

package/dist/esm/protocols/saml.external-connectors-models.schemas.d.ts

@@ -1,135 +0,0 @@
-import { z } from "zod";
-import { ExternalProvider_ExchangeProtocol_Configuration_Base, ExternalProvider_ExchangeProtocol_Kind, ExternalProvider_ExchangeProtocol_Profile_Base } from "../core/commons.external-connectors-models.schemas";
-export type SAMLProvider_Profile = ExternalProvider_ExchangeProtocol_Profile_Base;
-export type SAMLProvider_Configuration = ExternalProvider_ExchangeProtocol_Configuration_Base;
-export declare const SAMLProvider_ProfileSchema: z.ZodObject<{
-    endpoints: z.ZodOptional<z.ZodRecord<z.ZodEnum<typeof import("..").APPLICATION_ENVIRONMENT>, z.ZodString>>;
-    availableAuthMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof import("..").ExternalProvider_Auth_Kind>>>;
-    authProfiles: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.API_KEY>;
-        locationField: z.ZodDefault<z.ZodString>;
-        prefix: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.HMAC_SIGNATURE>;
-        locationField: z.ZodDefault<z.ZodString>;
-        algorithm: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_HMAC_Signature_Algorithm>>;
-        signaturePayload: z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
-            body: "body";
-            timestamp: "timestamp";
-        }>>;
-        timestampHeader: z.ZodOptional<z.ZodString>;
-        nonceHeader: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.BEARER>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        prefix: z.ZodDefault<z.ZodString>;
-        format: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_Bearer_Format>>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.OPENID_CONNECT>;
-        discoveryUrl: z.ZodOptional<z.ZodURL>;
-        issuer: z.ZodOptional<z.ZodString>;
-        audience: z.ZodOptional<z.ZodString>;
-        validationMode: z.ZodOptional<z.ZodEnum<{
-            jwks: "jwks";
-            introspection: "introspection";
-            local: "local";
-        }>>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.OAUTH2>;
-        oauth2ProviderRef: z.ZodOptional<z.ZodString>;
-        authUrl: z.ZodOptional<z.ZodURL>;
-        tokenUrl: z.ZodOptional<z.ZodURL>;
-        refreshUrl: z.ZodOptional<z.ZodURL>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        grantType: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_GrantType>>;
-        tokenEndpointAuthMethod: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_TokenEndpoint_AuthMethod>>;
-        pkce: z.ZodOptional<z.ZodBoolean>;
-        pkceMethod: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_PKCE_Method>>;
-        prompt: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_Prompt>>;
-        accessType: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_AccessType>>;
-        extraAuthParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        extraTokenParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        tokenFormat: z.ZodDefault<z.ZodEnum<{
-            token: "token";
-            bearer: "bearer";
-            oauth: "oauth";
-            custom: "custom";
-        }>>;
-        customTokenPrefix: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.BASIC>;
-        usernameRef: z.ZodOptional<z.ZodString>;
-        passwordRef: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.NONE>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.FRONTEND_SECRET>;
-        frontendOnly: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
-        ref: z.ZodOptional<z.ZodString>;
-        isDefault: z.ZodDefault<z.ZodBoolean>;
-        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
-        locationField: z.ZodDefault<z.ZodString>;
-        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.MUTUAL_TLS>;
-        certificateRef: z.ZodOptional<z.ZodString>;
-        privateKeyRef: z.ZodOptional<z.ZodString>;
-        caRef: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "kind">>>;
-}, z.core.$strip>;
-export declare const SAMLProvider_ConfigurationSchema: z.ZodObject<{
-    enabled: z.ZodBoolean;
-    authConfig: z.ZodOptional<z.ZodObject<{
-        authKind: z.ZodEnum<typeof import("..").ExternalProvider_Auth_Kind>;
-        profileRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        isDefault: z.ZodOptional<z.ZodBoolean>;
-        secretRef: z.ZodString;
-    }, z.core.$strip>>;
-    rateLimitConfig: z.ZodOptional<z.ZodObject<{
-        maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        minTime: z.ZodOptional<z.ZodNumber>;
-        reservoir: z.ZodOptional<z.ZodNumber>;
-        reservoirRefreshInterval: z.ZodOptional<z.ZodNumber>;
-        reservoirRefreshAmount: z.ZodOptional<z.ZodNumber>;
-        priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const SAMLProvider_OperationSchema: z.ZodObject<{}, z.core.$strip>;
-export declare const SAMLProvider_StatusSchema: z.ZodObject<{
-    status: z.ZodEnum<typeof import("..").ExternalProvider_Status>;
-    lastCheckedAt: z.ZodString;
-    errorReason: z.ZodOptional<z.ZodString>;
-    protocolKind: z.ZodLiteral<ExternalProvider_ExchangeProtocol_Kind.SSO_SAML>;
-}, z.core.$strip>;
-export type SAMLProvider_Operation = z.infer<typeof SAMLProvider_OperationSchema>;
-export type SAMLProvider_Status = z.infer<typeof SAMLProvider_StatusSchema>;
-//# sourceMappingURL=saml.external-connectors-models.schemas.d.ts.map

package/dist/esm/protocols/saml.external-connectors-models.schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"saml.external-connectors-models.schemas.d.ts","sourceRoot":"","sources":["../../../../src/protocols/saml.external-connectors-models.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,oDAAoD,EAA8D,sCAAsC,EAAE,8CAA8C,EAA6G,MAAM,oDAAoD,CAAA;AAGxX,MAAM,MAAM,oBAAoB,GAAG,8CAA8C,CAAC;AAClF,MAAM,MAAM,0BAA0B,GAAG,oDAAoD,CAAC;AAE9F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAuD,CAAC;AAC/F,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;iBAA6D,CAAC;AAC3G,eAAO,MAAM,4BAA4B,gCAAe,CAAC;AACzD,eAAO,MAAM,yBAAyB;;;;;iBAEpC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/esm/protocols/saml.external-connectors-models.schemas.js

@@ -1,9 +0,0 @@
-import { z } from "zod";
-import { ExternalProvider_ExchangeProtocol_Configuration_BaseSchema, ExternalProvider_ExchangeProtocol_Kind, ExternalProvider_ExchangeProtocol_Profile_BaseSchema, ExternalProvider_ExchangeProtocol_Status_BaseSchema } from "../core/commons.external-connectors-models.schemas.js";
-export const SAMLProvider_ProfileSchema = ExternalProvider_ExchangeProtocol_Profile_BaseSchema;
-export const SAMLProvider_ConfigurationSchema = ExternalProvider_ExchangeProtocol_Configuration_BaseSchema;
-export const SAMLProvider_OperationSchema = z.object({});
-export const SAMLProvider_StatusSchema = ExternalProvider_ExchangeProtocol_Status_BaseSchema.extend({
-    protocolKind: z.literal(ExternalProvider_ExchangeProtocol_Kind.SSO_SAML),
-});
-//# sourceMappingURL=saml.external-connectors-models.schemas.js.map

package/dist/esm/protocols/saml.external-connectors-models.schemas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"saml.external-connectors-models.schemas.js","sourceRoot":"","sources":["../../../../src/protocols/saml.external-connectors-models.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAwD,0DAA0D,EAAE,sCAAsC,EAAkD,oDAAoD,EAAE,mDAAmD,EAAE,MAAM,oDAAoD,CAAA;AAMxX,MAAM,CAAC,MAAM,0BAA0B,GAAG,oDAAoD,CAAC;AAC/F,MAAM,CAAC,MAAM,gCAAgC,GAAG,0DAA0D,CAAC;AAC3G,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACzD,MAAM,CAAC,MAAM,yBAAyB,GAAG,mDAAmD,CAAC,MAAM,CAAC;IAClG,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,sCAAsC,CAAC,QAAQ,CAAC;CACzE,CAAC,CAAC","sourcesContent":["import { z } from \"zod\"\nimport { ExternalProvider_ExchangeProtocol_Configuration_Base, ExternalProvider_ExchangeProtocol_Configuration_BaseSchema, ExternalProvider_ExchangeProtocol_Kind, ExternalProvider_ExchangeProtocol_Profile_Base, ExternalProvider_ExchangeProtocol_Profile_BaseSchema, ExternalProvider_ExchangeProtocol_Status_BaseSchema } from \"../core/commons.external-connectors-models.schemas\"\n\n// Type aliases for semantic clarity\nexport type SAMLProvider_Profile = ExternalProvider_ExchangeProtocol_Profile_Base;\nexport type SAMLProvider_Configuration = ExternalProvider_ExchangeProtocol_Configuration_Base;\n\nexport const SAMLProvider_ProfileSchema = ExternalProvider_ExchangeProtocol_Profile_BaseSchema;\nexport const SAMLProvider_ConfigurationSchema = ExternalProvider_ExchangeProtocol_Configuration_BaseSchema;\nexport const SAMLProvider_OperationSchema = z.object({});\nexport const SAMLProvider_StatusSchema = ExternalProvider_ExchangeProtocol_Status_BaseSchema.extend({\n  protocolKind: z.literal(ExternalProvider_ExchangeProtocol_Kind.SSO_SAML),\n});\n\nexport type SAMLProvider_Operation = z.infer<typeof SAMLProvider_OperationSchema>;\nexport type SAMLProvider_Status = z.infer<typeof SAMLProvider_StatusSchema>;"]}

package/dist/esm/protocols/sms.standard-interface.schemas.d.ts

@@ -10,10 +10,10 @@ export declare const StandardSMS_SendResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;
     messageId: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
-        failed: "failed";
         queued: "queued";
         sent: "sent";
         delivered: "delivered";
+        failed: "failed";
     }>>;
 }, z.core.$strip>;
 export type StandardSMS_SendResponse = z.infer<typeof StandardSMS_SendResponseSchema>;
@@ -21,11 +21,11 @@ export declare const StandardSMS_ErrorSchema: z.ZodObject<{
     code: z.ZodEnum<{
         VALIDATION_ERROR: "VALIDATION_ERROR";
         PROVIDER_ERROR: "PROVIDER_ERROR";
-        INVALID_PHONE_NUMBER: "INVALID_PHONE_NUMBER";
         RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED";
         AUTHENTICATION_FAILED: "AUTHENTICATION_FAILED";
         QUOTA_EXCEEDED: "QUOTA_EXCEEDED";
         UNKNOWN_ERROR: "UNKNOWN_ERROR";
+        INVALID_PHONE_NUMBER: "INVALID_PHONE_NUMBER";
     }>;
     message: z.ZodString;
     provider: z.ZodOptional<z.ZodString>;