@cat-factory/contracts 0.333.0 → 0.335.0

package/dist/routes/service-catalog.d.ts

@@ -0,0 +1,298 @@
+import { ContractNoBody } from '@toad-contracts/valibot';
+import * as v from 'valibot';
+/**
+ * The connection, or null when the workspace has none.
+ *
+ * Null rather than a 404, because the SPA renders the connect FORM off this read: a 404 there
+ * would make "not connected yet" indistinguishable from "wrong workspace id" at exactly the
+ * moment the panel has to decide which of the two to show.
+ */
+export declare const getServiceCatalogContract: {
+    readonly method: "get";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.NullableSchema<v.ObjectSchema<{
+            readonly provider: v.PicklistSchema<["backstage"], undefined>;
+            readonly baseUrl: v.StringSchema<undefined>;
+            readonly authMode: v.PicklistSchema<["none", "static-token", "legacy-shared-secret", "oauth2-client-credentials", "basic", "headers"], undefined>;
+            readonly entityFilter: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly includeApis: v.BooleanSchema<undefined>;
+            readonly maxServices: v.NumberSchema<undefined>;
+            readonly lastSyncedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly lastSyncStatus: v.NullableSchema<v.PicklistSchema<["ok", "partial", "failed"], undefined>, undefined>;
+            readonly lastSyncMessage: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly connectedAt: v.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+    };
+};
+/**
+ * Connect or REPLACE the workspace's catalog connection.
+ *
+ * `PUT` rather than `POST`, because a credential has no meaningful partial edit and a second
+ * connection has no meaning: the workspace either points at a portal or it does not. Replacing
+ * deliberately does NOT drop what a prior connection imported: the next import reconciles
+ * against it, so re-entering a rotated token costs no catalog.
+ */
+export declare const connectServiceCatalogContract: {
+    readonly method: "put";
+    readonly pathResolver: () => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly provider: v.OptionalSchema<v.PicklistSchema<["backstage"], undefined>, undefined>;
+        readonly baseUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+        readonly auth: v.VariantSchema<"mode", [v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"none", undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"static-token", undefined>;
+            readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"legacy-shared-secret", undefined>;
+            readonly sharedSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"oauth2-client-credentials", undefined>;
+            readonly tokenUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+            readonly clientId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+            readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+            readonly scope: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+            readonly audience: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"basic", undefined>;
+            readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+            readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"headers", undefined>;
+            readonly headers: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.RegexAction<string, "must be a valid HTTP header name">]>;
+                readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>, v.RegexAction<string, "must not contain a line break">]>;
+            }, undefined>, undefined>, v.MinLengthAction<{
+                name: string;
+                value: string;
+            }[], 1, undefined>, v.MaxLengthAction<{
+                name: string;
+                value: string;
+            }[], 5, undefined>]>;
+        }, undefined>], undefined>;
+        readonly entityFilter: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 200, undefined>, v.RegexAction<string, "must be a single `key=value` term (letters, digits and `_.-:/@`)">]>, undefined>, v.MaxLengthAction<string[], 10, undefined>]>, undefined>;
+        readonly includeApis: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly maxServices: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly provider: v.PicklistSchema<["backstage"], undefined>;
+            readonly baseUrl: v.StringSchema<undefined>;
+            readonly authMode: v.PicklistSchema<["none", "static-token", "legacy-shared-secret", "oauth2-client-credentials", "basic", "headers"], undefined>;
+            readonly entityFilter: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly includeApis: v.BooleanSchema<undefined>;
+            readonly maxServices: v.NumberSchema<undefined>;
+            readonly lastSyncedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly lastSyncStatus: v.NullableSchema<v.PicklistSchema<["ok", "partial", "failed"], undefined>, undefined>;
+            readonly lastSyncMessage: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly connectedAt: v.NumberSchema<undefined>;
+        }, undefined>;
+    };
+};
+/**
+ * Disconnect: forget the credential AND tombstone every foundational service the connection
+ * produced.
+ *
+ * Tombstoning is the point rather than a side effect. Leaving the imported services behind
+ * would keep handing agents an estate nothing refreshes and nothing can explain the provenance
+ * of, which is worse than an empty catalog because it still reads as current.
+ */
+export declare const disconnectServiceCatalogContract: {
+    readonly method: "delete";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 204: typeof ContractNoBody;
+    };
+};
+/**
+ * Probe the portal with the SUBMITTED credentials, before they are stored.
+ *
+ * Takes a body rather than reading the stored row, so the operator finds out that a token is
+ * wrong while they still have it on screen. It answers a result rather than throwing for the
+ * same reason every other connection test does: a refused connection is the answer.
+ */
+export declare const probeServiceCatalogContract: {
+    readonly method: "post";
+    readonly pathResolver: () => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly provider: v.OptionalSchema<v.PicklistSchema<["backstage"], undefined>, undefined>;
+        readonly baseUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+        readonly auth: v.VariantSchema<"mode", [v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"none", undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"static-token", undefined>;
+            readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"legacy-shared-secret", undefined>;
+            readonly sharedSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"oauth2-client-credentials", undefined>;
+            readonly tokenUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+            readonly clientId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+            readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+            readonly scope: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+            readonly audience: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"basic", undefined>;
+            readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+            readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly mode: v.LiteralSchema<"headers", undefined>;
+            readonly headers: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.RegexAction<string, "must be a valid HTTP header name">]>;
+                readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>, v.RegexAction<string, "must not contain a line break">]>;
+            }, undefined>, undefined>, v.MinLengthAction<{
+                name: string;
+                value: string;
+            }[], 1, undefined>, v.MaxLengthAction<{
+                name: string;
+                value: string;
+            }[], 5, undefined>]>;
+        }, undefined>], undefined>;
+        readonly entityFilter: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 200, undefined>, v.RegexAction<string, "must be a single `key=value` term (letters, digits and `_.-:/@`)">]>, undefined>, v.MaxLengthAction<string[], 10, undefined>]>, undefined>;
+        readonly includeApis: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly maxServices: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly ok: v.BooleanSchema<undefined>;
+            readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly failureCause: v.OptionalSchema<v.PicklistSchema<["refused", "dns", "timeout", "aborted", "unreachable", "reset", "tls-untrusted", "tls-expired", "tls-hostname", "tls-protocol", "invalid-header", "unknown"], undefined>, undefined>;
+            readonly warnings: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                readonly code: v.PicklistSchema<["runner_manifest_no_release", "runner_manifest_no_status_path", "github_pat_classic_account_wide", "github_pat_scopes_beyond_need", "github_pat_scope_unreadable", "github_pat_no_scopes"], undefined>;
+                readonly message: v.StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Import now, rather than waiting out the autorefresh sweep's staleness window. */
+export declare const syncServiceCatalogContract: {
+    readonly method: "post";
+    readonly pathResolver: () => string;
+    readonly requestBodySchema: typeof ContractNoBody;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly upserted: v.NumberSchema<undefined>;
+            readonly tombstoned: v.NumberSchema<undefined>;
+            readonly unchanged: v.NumberSchema<undefined>;
+            readonly contracts: v.NumberSchema<undefined>;
+            readonly coverage: v.PicklistSchema<["complete", "truncated", "empty"], undefined>;
+            readonly skippedServices: v.NumberSchema<undefined>;
+            readonly skippedConflicts: v.NumberSchema<undefined>;
+            readonly skippedApis: v.NumberSchema<undefined>;
+            readonly status: v.PicklistSchema<["ok", "partial", "failed"], undefined>;
+        }, undefined>;
+    };
+};
+//# sourceMappingURL=service-catalog.d.ts.map

package/dist/routes/service-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog.d.ts","sourceRoot":"","sources":["../../src/routes/service-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAmB5B;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOpC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKxC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI3C,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtC,CAAA;AAEF,oFAAoF;AACpF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKrC,CAAA"}

package/dist/routes/service-catalog.js

@@ -0,0 +1,77 @@
+import { ContractNoBody, defineApiContract } from '@toad-contracts/valibot';
+import * as v from 'valibot';
+import { connectionTestResultSchema } from '../provider-config.js';
+import { connectServiceCatalogSchema, serviceCatalogConnectionSchema, serviceCatalogSyncResultSchema, } from '../service-catalog.js';
+import { errorResponses } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Service-catalog route contracts. See ServiceCatalogController in
+// @cat-factory/server. Mounted under `/workspaces/:workspaceId` only, so these literals
+// are relative to that prefix and the workspace id is read by the handler.
+//
+// One connection per workspace, so the resource is a SINGLETON: `PUT` replaces it, `GET`
+// reads it, `DELETE` disconnects. There is no id in any path, which is what keeps the
+// import's provenance a fact about the workspace rather than a row a caller has to track.
+// ---------------------------------------------------------------------------
+/**
+ * The connection, or null when the workspace has none.
+ *
+ * Null rather than a 404, because the SPA renders the connect FORM off this read: a 404 there
+ * would make "not connected yet" indistinguishable from "wrong workspace id" at exactly the
+ * moment the panel has to decide which of the two to show.
+ */
+export const getServiceCatalogContract = defineApiContract({
+    method: 'get',
+    pathResolver: () => '/service-catalog',
+    responsesByStatusCode: {
+        200: v.nullable(serviceCatalogConnectionSchema),
+        ...errorResponses,
+    },
+});
+/**
+ * Connect or REPLACE the workspace's catalog connection.
+ *
+ * `PUT` rather than `POST`, because a credential has no meaningful partial edit and a second
+ * connection has no meaning: the workspace either points at a portal or it does not. Replacing
+ * deliberately does NOT drop what a prior connection imported: the next import reconciles
+ * against it, so re-entering a rotated token costs no catalog.
+ */
+export const connectServiceCatalogContract = defineApiContract({
+    method: 'put',
+    pathResolver: () => '/service-catalog',
+    requestBodySchema: connectServiceCatalogSchema,
+    responsesByStatusCode: { 200: serviceCatalogConnectionSchema, ...errorResponses },
+});
+/**
+ * Disconnect: forget the credential AND tombstone every foundational service the connection
+ * produced.
+ *
+ * Tombstoning is the point rather than a side effect. Leaving the imported services behind
+ * would keep handing agents an estate nothing refreshes and nothing can explain the provenance
+ * of, which is worse than an empty catalog because it still reads as current.
+ */
+export const disconnectServiceCatalogContract = defineApiContract({
+    method: 'delete',
+    pathResolver: () => '/service-catalog',
+    responsesByStatusCode: { 204: ContractNoBody, ...errorResponses },
+});
+/**
+ * Probe the portal with the SUBMITTED credentials, before they are stored.
+ *
+ * Takes a body rather than reading the stored row, so the operator finds out that a token is
+ * wrong while they still have it on screen. It answers a result rather than throwing for the
+ * same reason every other connection test does: a refused connection is the answer.
+ */
+export const probeServiceCatalogContract = defineApiContract({
+    method: 'post',
+    pathResolver: () => '/service-catalog/probe',
+    requestBodySchema: connectServiceCatalogSchema,
+    responsesByStatusCode: { 200: connectionTestResultSchema, ...errorResponses },
+});
+/** Import now, rather than waiting out the autorefresh sweep's staleness window. */
+export const syncServiceCatalogContract = defineApiContract({
+    method: 'post',
+    pathResolver: () => '/service-catalog/sync',
+    requestBodySchema: ContractNoBody,
+    responsesByStatusCode: { 200: serviceCatalogSyncResultSchema, ...errorResponses },
+});
+//# sourceMappingURL=service-catalog.js.map

package/dist/routes/service-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog.js","sourceRoot":"","sources":["../../src/routes/service-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,8EAA8E;AAC9E,mEAAmE;AACnE,wFAAwF;AACxF,2EAA2E;AAC3E,EAAE;AACF,yFAAyF;AACzF,sFAAsF;AACtF,0FAA0F;AAC1F,8EAA8E;AAE9E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;IACzD,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,kBAAkB;IACtC,qBAAqB,EAAE;QACrB,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,8BAA8B,CAAC;QAC/C,GAAG,cAAc;KAClB;CACF,CAAC,CAAA;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,iBAAiB,CAAC;IAC7D,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,kBAAkB;IACtC,iBAAiB,EAAE,2BAA2B;IAC9C,qBAAqB,EAAE,EAAE,GAAG,EAAE,8BAA8B,EAAE,GAAG,cAAc,EAAE;CAClF,CAAC,CAAA;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,iBAAiB,CAAC;IAChE,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,GAAG,EAAE,CAAC,kBAAkB;IACtC,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;IAC3D,MAAM,EAAE,MAAM;IACd,YAAY,EAAE,GAAG,EAAE,CAAC,wBAAwB;IAC5C,iBAAiB,EAAE,2BAA2B;IAC9C,qBAAqB,EAAE,EAAE,GAAG,EAAE,0BAA0B,EAAE,GAAG,cAAc,EAAE;CAC9E,CAAC,CAAA;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,0BAA0B,GAAG,iBAAiB,CAAC;IAC1D,MAAM,EAAE,MAAM;IACd,YAAY,EAAE,GAAG,EAAE,CAAC,uBAAuB;IAC3C,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,8BAA8B,EAAE,GAAG,cAAc,EAAE;CAClF,CAAC,CAAA"}

package/dist/service-catalog.d.ts

@@ -0,0 +1,223 @@
+import * as v from 'valibot';
+/**
+ * Which developer-portal product a connection talks to.
+ *
+ * A picklist with one member rather than a bare literal, because the read surface, the SPA and
+ * the stored row all name it: adding Port / Cortex / OpsLevel later is a member plus an adapter,
+ * and every `Record<ServiceCatalogProvider, …>` fails to compile until it is mapped. The
+ * platform-neutral vocabulary below (`ServiceCatalogEntry` in the kernel) is what the importer
+ * consumes, so nothing downstream of the adapter knows the word "Backstage".
+ */
+export declare const serviceCatalogProviderSchema: v.PicklistSchema<["backstage"], undefined>;
+export type ServiceCatalogProvider = v.InferOutput<typeof serviceCatalogProviderSchema>;
+/**
+ * How the platform authenticates to a SELF-HOSTED portal.
+ *
+ * These are the shapes organisations actually run Backstage behind, and each needs a different
+ * request built, which is why this is a closed vocabulary rather than a free-form header bag:
+ *
+ * - `none`: no auth on the catalog API. Real, and common on an instance reachable only inside a
+ *   VPN. It is admissible ONLY because the base URL is held to the deployment's
+ *   `UrlSafetyPolicy`, so reaching a private host is an operator decision already made.
+ * - `static-token`: a service-to-service token from Backstage's `backend.auth.externalAccess`
+ *   (`type: static`), sent as `Authorization: Bearer <token>`. The vendor's own recommended
+ *   way for an external system to read the catalog.
+ * - `legacy-shared-secret`: the older external-access route, still what a great many
+ *   self-hosted instances are configured for: a short-lived HS256 JWT signed with a secret
+ *   from `backend.auth.keys[]`. The platform MINTS the token per request rather than storing
+ *   one, which is why the stored credential is the secret and not a bearer value.
+ * - `oauth2-client-credentials`: the portal sits behind an IdP or an identity-aware proxy
+ *   (Keycloak, Okta, Entra, Google IAP). The platform exchanges a client id/secret at the
+ *   token endpoint and sends the result as a bearer token.
+ * - `basic`: HTTP Basic, i.e. a reverse proxy in front of the portal.
+ * - `headers`: an explicit header list, for a gateway that authenticates on its own header
+ *   names. A LIST rather than one pair because the common case needs two (a Cloudflare Access
+ *   service token is `CF-Access-Client-Id` plus `CF-Access-Client-Secret`), and a single-pair
+ *   shape would have sent half a credential.
+ */
+export declare const serviceCatalogAuthModeSchema: v.PicklistSchema<["none", "static-token", "legacy-shared-secret", "oauth2-client-credentials", "basic", "headers"], undefined>;
+export type ServiceCatalogAuthMode = v.InferOutput<typeof serviceCatalogAuthModeSchema>;
+/** The credential half of a connection, discriminated by the auth mode it belongs to. */
+export declare const serviceCatalogAuthSchema: v.VariantSchema<"mode", [v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"none", undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"static-token", undefined>;
+    readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"legacy-shared-secret", undefined>;
+    readonly sharedSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"oauth2-client-credentials", undefined>;
+    /** The IdP's token endpoint. Held to the same URL policy as the portal's own base URL. */
+    readonly tokenUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+    readonly clientId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+    readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+    /** Optional `scope` / `audience` request parameters some IdPs require. */
+    readonly scope: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+    readonly audience: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"basic", undefined>;
+    readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+    readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"headers", undefined>;
+    readonly headers: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.RegexAction<string, "must be a valid HTTP header name">]>;
+        readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>, v.RegexAction<string, "must not contain a line break">]>;
+    }, undefined>, undefined>, v.MinLengthAction<{
+        name: string;
+        value: string;
+    }[], 1, undefined>, v.MaxLengthAction<{
+        name: string;
+        value: string;
+    }[], 5, undefined>]>;
+}, undefined>], undefined>;
+export type ServiceCatalogAuth = v.InferOutput<typeof serviceCatalogAuthSchema>;
+/**
+ * The default filter, applied when a connection names none: the portal's SERVICE-like
+ * components.
+ *
+ * A default rather than a required field, because the honest alternative is worse in both
+ * directions. Importing the WHOLE catalog would fold a thousand-entity estate into every
+ * design prompt (the exact cost ADR 0031 split the catalog and contract reads to avoid), while
+ * refusing to import without a filter makes the first connection fail on a vendor query language
+ * the operator has no reason to know yet. `kind=component` is the one term that is right for
+ * every Backstage instance, and a narrower estate (a tag, a system, an owner) is one term more.
+ */
+export declare const DEFAULT_SERVICE_CATALOG_FILTER: readonly string[];
+/** How many services ONE import may bring in, and the ceiling on that number. */
+export declare const DEFAULT_MAX_CATALOG_SERVICES = 200;
+export declare const MAX_CATALOG_SERVICES_CEILING = 1000;
+/** Connect (or re-connect) the workspace's service catalog. Replaces any prior connection. */
+export declare const connectServiceCatalogSchema: v.ObjectSchema<{
+    readonly provider: v.OptionalSchema<v.PicklistSchema<["backstage"], undefined>, undefined>;
+    /** The portal's base URL, e.g. `https://backstage.corp.internal`. */
+    readonly baseUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+    readonly auth: v.VariantSchema<"mode", [v.ObjectSchema<{
+        readonly mode: v.LiteralSchema<"none", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly mode: v.LiteralSchema<"static-token", undefined>;
+        readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly mode: v.LiteralSchema<"legacy-shared-secret", undefined>;
+        readonly sharedSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly mode: v.LiteralSchema<"oauth2-client-credentials", undefined>;
+        /** The IdP's token endpoint. Held to the same URL policy as the portal's own base URL. */
+        readonly tokenUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
+        readonly clientId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+        readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+        /** Optional `scope` / `audience` request parameters some IdPs require. */
+        readonly scope: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+        readonly audience: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly mode: v.LiteralSchema<"basic", undefined>;
+        readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+        readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly mode: v.LiteralSchema<"headers", undefined>;
+        readonly headers: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.RegexAction<string, "must be a valid HTTP header name">]>;
+            readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>, v.RegexAction<string, "must not contain a line break">]>;
+        }, undefined>, undefined>, v.MinLengthAction<{
+            name: string;
+            value: string;
+        }[], 1, undefined>, v.MaxLengthAction<{
+            name: string;
+            value: string;
+        }[], 5, undefined>]>;
+    }, undefined>], undefined>;
+    /**
+     * Portal-side filter terms, ANDed. Empty/absent ⇒ {@link DEFAULT_SERVICE_CATALOG_FILTER}.
+     * Filtering AT THE PORTAL rather than after the fetch is what keeps a large estate from being
+     * paged through in full on every refresh.
+     */
+    readonly entityFilter: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 200, undefined>, v.RegexAction<string, "must be a single `key=value` term (letters, digits and `_.-:/@`)">]>, undefined>, v.MaxLengthAction<string[], 10, undefined>]>, undefined>;
+    /**
+     * Whether to import the API definitions each service publishes (`spec.providesApis`).
+     * Defaults to true, being the half of the ask that lets a consumer call a shared service
+     * rather than merely know it exists.
+     */
+    readonly includeApis: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    /** Cap on imported services. Defaults to {@link DEFAULT_MAX_CATALOG_SERVICES}. */
+    readonly maxServices: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+}, undefined>;
+export type ConnectServiceCatalogInput = v.InferOutput<typeof connectServiceCatalogSchema>;
+/**
+ * How much of the portal's matching estate one import covered.
+ *
+ * Three states rather than a count, for the reason the repo-source `folderScan` coverage has
+ * three: each needs a different fix from the person who connected it, and `truncated` must never
+ * read as `complete`. An importer that reported only "42 services" would leave an operator with
+ * a 300-service estate believing the catalog is the estate.
+ */
+export declare const serviceCatalogCoverageSchema: v.PicklistSchema<["complete", "truncated", "empty"], undefined>;
+export type ServiceCatalogCoverage = v.InferOutput<typeof serviceCatalogCoverageSchema>;
+/** What the LAST import concluded, as the management surface reports it. */
+export declare const serviceCatalogSyncStatusSchema: v.PicklistSchema<["ok", "partial", "failed"], undefined>;
+export type ServiceCatalogSyncStatus = v.InferOutput<typeof serviceCatalogSyncStatusSchema>;
+/**
+ * The connection as the management surface sees it: never a credential, not even a masked one.
+ *
+ * `authMode` is here because it is the one part of the credential that is configuration rather
+ * than secret, because the operator has to see WHICH scheme a stored connection uses to know whether
+ * it still matches how the portal is deployed.
+ */
+export declare const serviceCatalogConnectionSchema: v.ObjectSchema<{
+    readonly provider: v.PicklistSchema<["backstage"], undefined>;
+    readonly baseUrl: v.StringSchema<undefined>;
+    readonly authMode: v.PicklistSchema<["none", "static-token", "legacy-shared-secret", "oauth2-client-credentials", "basic", "headers"], undefined>;
+    readonly entityFilter: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly includeApis: v.BooleanSchema<undefined>;
+    readonly maxServices: v.NumberSchema<undefined>;
+    readonly lastSyncedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly lastSyncStatus: v.NullableSchema<v.PicklistSchema<["ok", "partial", "failed"], undefined>, undefined>;
+    /**
+     * What the last import wants a human to know: the truncation, the unreadable definitions, or
+     * the transport failure. Null when the last pass had nothing to report, which is the only
+     * state that needs no sentence.
+     */
+    readonly lastSyncMessage: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly connectedAt: v.NumberSchema<undefined>;
+}, undefined>;
+export type ServiceCatalogConnection = v.InferOutput<typeof serviceCatalogConnectionSchema>;
+/** Outcome of one import: what changed in the catalog, and what the pass could not do. */
+export declare const serviceCatalogSyncResultSchema: v.ObjectSchema<{
+    readonly upserted: v.NumberSchema<undefined>;
+    /** Services this connection produced before and the portal no longer offers. */
+    readonly tombstoned: v.NumberSchema<undefined>;
+    readonly unchanged: v.NumberSchema<undefined>;
+    /** API definitions stored across every imported service. */
+    readonly contracts: v.NumberSchema<undefined>;
+    readonly coverage: v.PicklistSchema<["complete", "truncated", "empty"], undefined>;
+    /**
+     * Entities the filter matched that did NOT become a service: no usable identity, or a name
+     * that yields no slug. Zero and "nothing matched" are told apart by {@link coverage}, and a
+     * non-zero value here is the only thing that explains a catalog thinner than the portal's
+     * own entity count.
+     */
+    readonly skippedServices: v.NumberSchema<undefined>;
+    /**
+     * Portal services this pass REFUSED to write because the workspace already registers a service
+     * under that id by another route (an upload, a linked repo).
+     *
+     * Its own count rather than folded into {@link skippedServices}, because the two name opposite
+     * faults with opposite remedies: a skipped service is an entity the PORTAL describes in a way
+     * this platform cannot use, and this is a collision between two things the workspace itself
+     * did. Refusing is the only safe disposition, since overwriting would silently replace a
+     * hand-authored service (and its uploaded contracts, and any platform capability it was granted)
+     * with the portal's row, and disconnecting would then tombstone the original.
+     */
+    readonly skippedConflicts: v.NumberSchema<undefined>;
+    /**
+     * API definitions a service DECLARES that this pass could not store: a type the platform
+     * serves no format for, an entity the portal would not return, an empty or oversized
+     * definition, or an id that collides with another interface of the same service. Reported
+     * rather than dropped, because a service listed with no interface reads to an agent as a
+     * service that publishes none.
+     */
+    readonly skippedApis: v.NumberSchema<undefined>;
+    readonly status: v.PicklistSchema<["ok", "partial", "failed"], undefined>;
+}, undefined>;
+export type ServiceCatalogSyncResult = v.InferOutput<typeof serviceCatalogSyncResultSchema>;
+//# sourceMappingURL=service-catalog.d.ts.map

package/dist/service-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog.d.ts","sourceRoot":"","sources":["../src/service-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAqB5B;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,4CAA4B,CAAA;AACrE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,4BAA4B,gIAOvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA;AA0BvF,yFAAyF;AACzF,eAAO,MAAM,wBAAwB;;;;;;;;;;IAMjC,0FAA0F;;;;IAI1F,0EAA0E;;;;;;;;;;;;;;;;;;;0BAa5E,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAqB/E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B,EAAE,SAAS,MAAM,EAAuB,CAAA;AAEnF,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,MAAM,CAAA;AAC/C,eAAO,MAAM,4BAA4B,OAAQ,CAAA;AAEjD,8FAA8F;AAC9F,eAAO,MAAM,2BAA2B;;IAEtC,qEAAqE;;;;;;;;;;;;QA3DnE,0FAA0F;;;;QAI1F,0EAA0E;;;;;;;;;;;;;;;;;;;;IA0D5E;;;;OAIG;;IAEH;;;;OAIG;;IAEH,kFAAkF;;aAIlF,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE1F;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,iEAWvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF,4EAA4E;AAC5E,eAAO,MAAM,8BAA8B,0DAWzC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;IASzC;;;;OAIG;;;aAGH,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F,0FAA0F;AAC1F,eAAO,MAAM,8BAA8B;;IAEzC,gFAAgF;;;IAGhF,4DAA4D;;;IAG5D;;;;;OAKG;;IAEH;;;;;;;;;;OAUG;;IAEH;;;;;;OAMG;;;aAGH,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAA"}