@gscdump/contracts 1.3.2 → 1.4.1

package/dist/v1/documents.mjs

@@ -0,0 +1,227 @@
+import { createGscdumpV1Protocol } from "./operations.mjs";
+import { z } from "zod";
+function compareStrings(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function orderedJson(value) {
+	if (Array.isArray(value)) return value.map(orderedJson);
+	if (value === null || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => compareStrings(left, right)).map(([key, item]) => [key, orderedJson(item)]));
+}
+function serializeContractDocument(document) {
+	return `${JSON.stringify(orderedJson(document), null, 2)}\n`;
+}
+function jsonSchema(schema) {
+	const { $schema: _schema, ...body } = z.toJSONSchema(schema);
+	return orderedJson(body);
+}
+function rewriteDefinitionRefs(value, references) {
+	if (Array.isArray(value)) return value.map((item) => rewriteDefinitionRefs(item, references));
+	if (value === null || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+		if (key === "$ref" && typeof item === "string" && item.startsWith("#/$defs/")) {
+			const name = item.slice(8);
+			const reference = references[name];
+			if (!reference) throw new TypeError(`JSON Schema references an unknown definition: ${name}`);
+			return [key, reference];
+		}
+		return [key, rewriteDefinitionRefs(item, references)];
+	}));
+}
+function registerComponentSchema(schema, prefix, components) {
+	const { $defs, ...body } = jsonSchema(schema);
+	if (!$defs) return body;
+	const definitions = $defs;
+	const safePrefix = prefix.replace(/[^\w.-]/g, "_");
+	const references = Object.fromEntries(Object.keys(definitions).map((name) => {
+		return [name, `#/components/schemas/${safePrefix}.${name}`];
+	}));
+	for (const [name, definition] of Object.entries(definitions)) {
+		const componentName = `${safePrefix}.${name}`;
+		if (componentName in components) throw new TypeError(`Duplicate generated component schema: ${componentName}`);
+		components[componentName] = rewriteDefinitionRefs(definition, references);
+	}
+	return rewriteDefinitionRefs(body, references);
+}
+function objectSchemaProperties(schema) {
+	const document = jsonSchema(schema);
+	return {
+		properties: document.properties ?? {},
+		required: new Set(document.required ?? [])
+	};
+}
+function requestParameters(operation) {
+	const parameters = [];
+	if (operation.request.params) {
+		const { properties } = objectSchemaProperties(operation.request.params);
+		for (const name of operation.path.matchAll(/\{([^{}]+)\}/g)) parameters.push({
+			name: name[1],
+			in: "path",
+			required: true,
+			schema: properties[name[1]] ?? {}
+		});
+	}
+	for (const location of ["query", "headers"]) {
+		const schema = operation.request[location];
+		if (!schema) continue;
+		const { properties, required } = objectSchemaProperties(schema);
+		for (const [name, property] of Object.entries(properties)) parameters.push({
+			name,
+			in: location === "headers" ? "header" : "query",
+			required: required.has(name),
+			schema: property
+		});
+	}
+	return parameters;
+}
+function operationDocument(operation, components) {
+	const errorComponentName = `${operation.id}.error`;
+	if (errorComponentName in components) throw new TypeError(`Duplicate generated component schema: ${errorComponentName}`);
+	components[errorComponentName] = registerComponentSchema(operation.errorResponse.producer, errorComponentName, components);
+	const errorSchema = { $ref: `#/components/schemas/${errorComponentName}` };
+	const responses = Object.fromEntries(Object.entries(operation.responses).sort(([left], [right]) => Number(left) - Number(right)).map(([status, response]) => [status, {
+		description: status.startsWith("2") ? "Successful response" : "Documented response",
+		content: { "application/json": { schema: registerComponentSchema(response.producer, `${operation.id}.response.${status}`, components) } }
+	}]));
+	responses.default = {
+		description: "Stable error envelope",
+		content: { "application/json": { schema: errorSchema } }
+	};
+	responses["4XX"] = {
+		description: "Declared client error",
+		content: { "application/json": { schema: errorSchema } }
+	};
+	responses["5XX"] = {
+		description: "Safe internal or contract error",
+		content: { "application/json": { schema: errorSchema } }
+	};
+	const document = {
+		"operationId": operation.id,
+		"summary": operation.docs.summary,
+		"description": operation.docs.description,
+		"tags": operation.docs.tags,
+		"security": operation.auth.credentials.map((credential) => ({ [credential]: [] })),
+		"parameters": requestParameters(operation),
+		responses,
+		"x-gscdump-errors": operation.errors,
+		"x-gscdump-examples": operation.docs.examples,
+		"x-gscdump-lifecycle": operation.lifecycle,
+		"x-gscdump-resources": operation.resources,
+		"x-gscdump-scopes": operation.auth.scopes,
+		"x-gscdump-ownership": operation.auth.ownership,
+		"x-gscdump-semantics": operation.semantics,
+		"x-gscdump-visibility": operation.visibility
+	};
+	if (operation.request.body) document.requestBody = {
+		required: true,
+		content: { "application/json": { schema: registerComponentSchema(operation.request.body, `${operation.id}.request.body`, components) } }
+	};
+	return document;
+}
+function openApiDocument(surface) {
+	const paths = {};
+	const schemas = {};
+	for (const operation of Object.values(surface.operations).sort((left, right) => {
+		return compareStrings(`${left.path}\0${left.method}\0${left.id}`, `${right.path}\0${right.method}\0${right.id}`);
+	})) {
+		const path = `${surface.prefix}${operation.path}`;
+		paths[path] ??= {};
+		paths[path][operation.method.toLowerCase()] = operationDocument(operation, schemas);
+	}
+	return {
+		openapi: "3.1.0",
+		jsonSchemaDialect: "https://json-schema.org/draft/2020-12/schema",
+		info: {
+			title: `gscdump ${surface.name} API`,
+			version: surface.version,
+			license: {
+				name: "MIT",
+				identifier: "MIT"
+			}
+		},
+		servers: [{ url: "https://gscdump.com" }],
+		paths,
+		components: {
+			schemas,
+			securitySchemes: {
+				user_key: {
+					type: "http",
+					scheme: "bearer",
+					bearerFormat: "gscdump user key"
+				},
+				partner_key: {
+					type: "http",
+					scheme: "bearer",
+					bearerFormat: "gscdump partner key"
+				}
+			}
+		}
+	};
+}
+function asyncApiDocument(protocol) {
+	const schemas = {};
+	const clientFrameSchema = registerComponentSchema(protocol.schemas.clientFrame, "clientFrame", schemas);
+	const serverFrameSchema = registerComponentSchema(protocol.schemas.serverFrame, "serverFrame", schemas);
+	return {
+		"asyncapi": "3.1.0",
+		"info": {
+			title: "gscdump realtime API",
+			version: "1.0"
+		},
+		"servers": { production: {
+			"host": "gscdump.com",
+			"pathname": "/ws/v1",
+			"protocol": "wss",
+			"x-websocket-subprotocol": protocol.constants.realtimeSubprotocol
+		} },
+		"channels": { notifications: {
+			address: "/",
+			messages: {
+				clientFrame: { $ref: "#/components/messages/clientFrame" },
+				serverFrame: { $ref: "#/components/messages/serverFrame" }
+			}
+		} },
+		"operations": {
+			receiveServerFrame: {
+				action: "receive",
+				channel: { $ref: "#/channels/notifications" },
+				messages: [{ $ref: "#/channels/notifications/messages/serverFrame" }]
+			},
+			sendClientFrame: {
+				action: "send",
+				channel: { $ref: "#/channels/notifications" },
+				messages: [{ $ref: "#/channels/notifications/messages/clientFrame" }]
+			}
+		},
+		"components": {
+			messages: {
+				clientFrame: {
+					name: "clientFrame",
+					contentType: "application/json",
+					payload: clientFrameSchema
+				},
+				serverFrame: {
+					name: "serverFrame",
+					contentType: "application/json",
+					payload: serverFrameSchema
+				}
+			},
+			schemas
+		},
+		"x-heartbeat-text-frames": {
+			ping: protocol.constants.ping,
+			pong: protocol.constants.pong
+		},
+		"x-gscdump-event-semantics": protocol.constants.eventSemantics
+	};
+}
+function createGscdumpV1Documents() {
+	const protocol = createGscdumpV1Protocol();
+	return {
+		"openapi.partner.v1.json": openApiDocument(protocol.surfaces.partner),
+		"openapi.analytics.v1.json": openApiDocument(protocol.surfaces.analytics),
+		"openapi.realtime.v1.json": openApiDocument(protocol.surfaces.realtime),
+		"asyncapi.realtime.v1.json": asyncApiDocument(protocol)
+	};
+}
+export { createGscdumpV1Documents, serializeContractDocument };

package/dist/v1/http.d.mts

@@ -0,0 +1,94 @@
+import { ZodRawShape, ZodTypeAny, z } from "zod";
+declare const HTTP_V1_SURFACES: readonly ['partner', 'analytics', 'realtime'];
+declare const HTTP_V1_METHODS: readonly ['DELETE', 'GET', 'PATCH', 'POST'];
+declare const HTTP_V1_CREDENTIALS: readonly ['user_key', 'partner_key'];
+declare const HTTP_V1_SCOPES: readonly ["users:read", "users:write", "sites:read", "sites:write", "analytics:read", "analytics:execute", "indexing:read", "indexing:write", "sitemaps:read", "sitemaps:write", "settings:read", "settings:write", "realtime:connect", "teams:read", "teams:write"];
+declare const HTTP_V1_CREDENTIAL_SCOPES: {
+  readonly user_key: readonly ["users:read", "users:write", "sites:read", "sites:write", "analytics:read", "analytics:execute", "indexing:read", "indexing:write", "sitemaps:read", "sitemaps:write", "settings:read", "settings:write", "realtime:connect"];
+  readonly partner_key: readonly ["users:read", "users:write", "sites:read", "sites:write", "analytics:read", "analytics:execute", "indexing:read", "indexing:write", "sitemaps:read", "sitemaps:write", "settings:read", "settings:write", "realtime:connect", "teams:read", "teams:write"];
+};
+declare const HTTP_V1_ERROR_CODES: readonly ['invalid_request', 'unauthorized', 'forbidden', 'user_not_found', 'site_not_found', 'rate_limited', 'realtime_unavailable', 'internal_error', 'contract_violation'];
+type HttpV1SurfaceName = typeof HTTP_V1_SURFACES[number];
+type HttpV1Method = typeof HTTP_V1_METHODS[number];
+type HttpV1Credential = typeof HTTP_V1_CREDENTIALS[number];
+type HttpV1Scope = typeof HTTP_V1_SCOPES[number];
+type HttpV1ErrorCode = typeof HTTP_V1_ERROR_CODES[number];
+type HttpV1Visibility = 'internal' | 'public';
+type HttpV1OwnershipRule = 'self' | 'linked_user' | 'authorized_site' | 'partner_tenant' | 'principal_stream';
+type HttpV1ResourceType = 'partner.user' | 'partner.team' | 'user.sites' | 'site.registration' | 'site.lifecycle' | 'site.analytics' | 'site.sitemaps' | 'site.indexing' | 'site.auth';
+interface CompatibleResponseSchema<TProducer extends ZodTypeAny = ZodTypeAny, TClient extends ZodTypeAny = ZodTypeAny> {
+  producer: TProducer;
+  client: TClient;
+}
+interface HttpV1RequestSchemas {
+  params: ZodTypeAny | null;
+  query: ZodTypeAny | null;
+  headers: ZodTypeAny | null;
+  body: ZodTypeAny | null;
+}
+interface HttpV1Semantics {
+  kind: 'mutation' | 'query';
+  sideEffects: 'none' | 'state';
+  idempotent: boolean;
+  retry: 'idempotent' | 'never';
+  readConsistency: 'primary' | 'replica-ok' | null;
+}
+interface HttpV1ResourceReference {
+  type: HttpV1ResourceType;
+  idFrom: `params.${string}` | 'principal.id';
+}
+interface HttpV1OperationDefinition {
+  id: string;
+  method: HttpV1Method;
+  path: `/${string}`;
+  visibility: HttpV1Visibility;
+  semantics: HttpV1Semantics;
+  auth: {
+    credentials: readonly HttpV1Credential[];
+    scopes: readonly HttpV1Scope[];
+    ownership: readonly {
+      credential: HttpV1Credential;
+      rule: HttpV1OwnershipRule;
+    }[];
+  };
+  request: HttpV1RequestSchemas;
+  responses: Readonly<Record<number, CompatibleResponseSchema>>;
+  errors: readonly HttpV1ErrorCode[];
+  errorResponse: CompatibleResponseSchema;
+  resources: {
+    reads: readonly HttpV1ResourceReference[];
+    changes: readonly HttpV1ResourceReference[];
+  };
+  lifecycle: {
+    introduced: `${number}.${number}.${number}`;
+    deprecated?: `${number}.${number}.${number}`;
+    sunset?: string;
+  };
+  docs: {
+    summary: string;
+    description: string;
+    tags: readonly string[];
+    examples: {
+      request: unknown;
+      response: unknown;
+    };
+  };
+}
+interface HttpV1Surface<TOperations extends Readonly<Record<string, HttpV1OperationDefinition>> = Readonly<Record<string, HttpV1OperationDefinition>>> {
+  name: HttpV1SurfaceName;
+  prefix: `/api/${HttpV1SurfaceName}/v1`;
+  version: '1.0';
+  operations: TOperations;
+}
+declare function defineHttpOperation<const TOperation extends HttpV1OperationDefinition>(operation: TOperation): TOperation;
+declare function defineHttpSurface<const TOperations extends Readonly<Record<string, HttpV1OperationDefinition>>>(surface: HttpV1Surface<TOperations>): HttpV1Surface<TOperations>;
+declare function defineResponseObject<const TProducerShape extends ZodRawShape, const TClientShape extends ZodRawShape = TProducerShape>(producerShape: TProducerShape, clientShape?: TClientShape): CompatibleResponseSchema<z.ZodObject<TProducerShape>, z.ZodObject<TClientShape>>;
+declare function defineSuccessResponse<const TDataProducer extends ZodTypeAny, const TDataClient extends ZodTypeAny, const TMetaProducer extends ZodTypeAny, const TMetaClient extends ZodTypeAny>(data: CompatibleResponseSchema<TDataProducer, TDataClient>, meta: CompatibleResponseSchema<TMetaProducer, TMetaClient>): CompatibleResponseSchema<z.ZodObject<{
+  data: TDataProducer;
+  meta: TMetaProducer;
+}>, z.ZodObject<{
+  data: TDataClient;
+  meta: TMetaClient;
+}>>;
+declare function buildHttpOperationPath(surface: HttpV1Surface, operation: HttpV1OperationDefinition, params?: unknown): string;
+export { CompatibleResponseSchema, HTTP_V1_CREDENTIALS, HTTP_V1_CREDENTIAL_SCOPES, HTTP_V1_ERROR_CODES, HTTP_V1_METHODS, HTTP_V1_SCOPES, HTTP_V1_SURFACES, HttpV1Credential, HttpV1ErrorCode, HttpV1Method, HttpV1OperationDefinition, HttpV1OwnershipRule, HttpV1RequestSchemas, HttpV1ResourceReference, HttpV1ResourceType, HttpV1Scope, HttpV1Semantics, HttpV1Surface, HttpV1SurfaceName, HttpV1Visibility, buildHttpOperationPath, defineHttpOperation, defineHttpSurface, defineResponseObject, defineSuccessResponse };

package/dist/v1/http.mjs

@@ -0,0 +1,162 @@
+import { z } from "zod";
+const HTTP_V1_SURFACES = [
+	"partner",
+	"analytics",
+	"realtime"
+];
+const HTTP_V1_METHODS = [
+	"DELETE",
+	"GET",
+	"PATCH",
+	"POST"
+];
+const HTTP_V1_CREDENTIALS = ["user_key", "partner_key"];
+const HTTP_V1_USER_KEY_SCOPES = [
+	"users:read",
+	"users:write",
+	"sites:read",
+	"sites:write",
+	"analytics:read",
+	"analytics:execute",
+	"indexing:read",
+	"indexing:write",
+	"sitemaps:read",
+	"sitemaps:write",
+	"settings:read",
+	"settings:write",
+	"realtime:connect"
+];
+const HTTP_V1_SCOPES = [
+	...HTTP_V1_USER_KEY_SCOPES,
+	"teams:read",
+	"teams:write"
+];
+const HTTP_V1_CREDENTIAL_SCOPES = {
+	user_key: HTTP_V1_USER_KEY_SCOPES,
+	partner_key: HTTP_V1_SCOPES
+};
+const HTTP_V1_ERROR_CODES = [
+	"invalid_request",
+	"unauthorized",
+	"forbidden",
+	"user_not_found",
+	"site_not_found",
+	"rate_limited",
+	"realtime_unavailable",
+	"internal_error",
+	"contract_violation"
+];
+function pathParameterNames(path) {
+	return [...path.matchAll(/\{([^{}]+)\}/g)].map((match) => match[1]);
+}
+function isSafePathTemplate(path) {
+	return /^\/(?:[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?|\{[a-z][A-Za-z0-9]*\})(?:\/(?:[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?|\{[a-z][A-Za-z0-9]*\}))*$/.test(path);
+}
+function objectSchemaKeys(schema) {
+	return schema instanceof z.ZodObject ? Object.keys(schema.shape) : null;
+}
+function assertRequestLocations(request, operationId) {
+	for (const location of [
+		"params",
+		"query",
+		"headers",
+		"body"
+	]) if (!(location in request) || request[location] === void 0) throw new TypeError(`${operationId}: request.${location} must be a schema or null`);
+}
+function assertPathContract(operation) {
+	const names = pathParameterNames(operation.path);
+	if (new Set(names).size !== names.length) throw new TypeError(`${operation.id}: path parameters must be unique`);
+	if (names.length === 0) {
+		if (operation.request.params !== null) throw new TypeError(`${operation.id}: params must be null when the path has no parameters`);
+		return;
+	}
+	if (operation.request.params === null) throw new TypeError(`${operation.id}: path parameters require a params schema`);
+	const schemaKeys = objectSchemaKeys(operation.request.params);
+	if (!schemaKeys) throw new TypeError(`${operation.id}: params must be an object schema`);
+	if (names.join("\0") !== schemaKeys.join("\0")) throw new TypeError(`${operation.id}: params schema keys (${schemaKeys.join(", ")}) must match path order (${names.join(", ")})`);
+}
+function assertOperation(operation) {
+	if (!/^[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)+$/.test(operation.id)) throw new TypeError(`${operation.id}: operation ID must be a stable dotted lowercase identifier`);
+	if (!isSafePathTemplate(operation.path)) throw new TypeError(`${operation.id}: path must be a safe literal surface-relative template`);
+	assertRequestLocations(operation.request, operation.id);
+	assertPathContract(operation);
+	if (operation.semantics.kind === "query") {
+		if (operation.semantics.sideEffects !== "none") throw new TypeError(`${operation.id}: query operations cannot declare state side effects`);
+		if (!operation.semantics.idempotent) throw new TypeError(`${operation.id}: query operations must be idempotent`);
+		if (operation.semantics.readConsistency === null) throw new TypeError(`${operation.id}: query operations must declare read consistency`);
+	} else {
+		if (operation.semantics.sideEffects !== "state") throw new TypeError(`${operation.id}: mutation operations must declare state side effects`);
+		if (operation.semantics.readConsistency !== null) throw new TypeError(`${operation.id}: mutations cannot declare read consistency`);
+	}
+	if (operation.auth.credentials.includes("user_key") && operation.semantics.kind === "query" && operation.semantics.readConsistency !== "primary") throw new TypeError(`${operation.id}: user_key queries must use primary consistency`);
+	if (operation.semantics.idempotent && operation.semantics.retry !== "idempotent") throw new TypeError(`${operation.id}: idempotent operations must use the idempotent retry policy`);
+	if (!operation.semantics.idempotent && operation.semantics.retry !== "never") throw new TypeError(`${operation.id}: non-idempotent operations cannot be retried automatically`);
+	if (operation.auth.credentials.length === 0 || operation.auth.scopes.length === 0) throw new TypeError(`${operation.id}: auth credentials and scopes are required`);
+	for (const credential of operation.auth.credentials) {
+		const availableScopes = HTTP_V1_CREDENTIAL_SCOPES[credential];
+		const unavailableScope = operation.auth.scopes.find((scope) => !availableScopes.includes(scope));
+		if (unavailableScope) throw new TypeError(`${operation.id}: ${credential} does not grant the ${unavailableScope} scope`);
+	}
+	const ownershipCredentials = operation.auth.ownership.map((ownership) => ownership.credential);
+	if (ownershipCredentials.length !== operation.auth.credentials.length || new Set(ownershipCredentials).size !== ownershipCredentials.length || operation.auth.credentials.some((credential) => !ownershipCredentials.includes(credential))) throw new TypeError(`${operation.id}: every credential requires exactly one ownership rule`);
+	if (operation.errors.length === 0) throw new TypeError(`${operation.id}: declared stable errors are required`);
+	if (!operation.errorResponse?.producer || !operation.errorResponse.client) throw new TypeError(`${operation.id}: an operation-specific error response schema is required`);
+	if (Object.keys(operation.responses).length === 0) throw new TypeError(`${operation.id}: at least one response is required`);
+	const pathParameters = new Set(pathParameterNames(operation.path));
+	for (const reference of [...operation.resources.reads, ...operation.resources.changes]) if (reference.idFrom.startsWith("params.") && !pathParameters.has(reference.idFrom.slice(7))) throw new TypeError(`${operation.id}: resource reference ${reference.idFrom} is not a declared path parameter`);
+	if (operation.docs.summary.length === 0 || operation.docs.description.length === 0 || operation.docs.tags.length === 0) throw new TypeError(`${operation.id}: public documentation metadata is incomplete`);
+}
+function defineHttpOperation(operation) {
+	assertOperation(operation);
+	return operation;
+}
+function defineHttpSurface(surface) {
+	if (surface.prefix !== `/api/${surface.name}/v1`) throw new TypeError(`${surface.name}: prefix must retain the surface and v1 major`);
+	if (surface.version !== "1.0") throw new TypeError(`${surface.name}: wire version must be 1.0`);
+	const ids = /* @__PURE__ */ new Set();
+	const routes = /* @__PURE__ */ new Set();
+	for (const [key, operation] of Object.entries(surface.operations)) {
+		assertOperation(operation);
+		if (!operation.id.startsWith(`${surface.name}.`)) throw new TypeError(`${surface.name}: operation ID ${operation.id} must use the surface namespace`);
+		if (ids.has(operation.id)) throw new TypeError(`${surface.name}: duplicate operation ID ${operation.id}`);
+		ids.add(operation.id);
+		const route = `${operation.method} ${operation.path}`;
+		if (routes.has(route)) throw new TypeError(`${surface.name}: duplicate method/path ${route}`);
+		routes.add(route);
+		if (key.length === 0) throw new TypeError(`${surface.name}: operation registry keys cannot be empty`);
+	}
+	return surface;
+}
+function defineResponseObject(producerShape, clientShape) {
+	return {
+		producer: z.strictObject(producerShape),
+		client: z.looseObject(clientShape ?? producerShape)
+	};
+}
+function defineSuccessResponse(data, meta) {
+	return defineResponseObject({
+		data: data.producer,
+		meta: meta.producer
+	}, {
+		data: data.client,
+		meta: meta.client
+	});
+}
+function buildHttpOperationPath(surface, operation, params) {
+	if (!operation.id.startsWith(`${surface.name}.`)) throw new TypeError(`${operation.id}: operation does not belong to the ${surface.name} surface`);
+	if (pathParameterNames(operation.path).length === 0) {
+		if (params !== void 0 && params !== null && (typeof params !== "object" || Object.keys(params).length > 0)) throw new TypeError(`${operation.id}: this operation has no path parameters`);
+		return `${surface.prefix}${operation.path}`;
+	}
+	if (operation.request.params === null) throw new TypeError(`${operation.id}: operation has an invalid path contract`);
+	const parsed = operation.request.params.parse(params);
+	const relativePath = operation.path.replace(/\{([^{}]+)\}/g, (_match, name) => {
+		const value = parsed[name];
+		if (typeof value !== "string" && typeof value !== "number") throw new TypeError(`${operation.id}: path parameter ${name} must serialize as a string or number`);
+		const serialized = String(value);
+		if (serialized.length === 0 || serialized === "." || serialized === "..") throw new TypeError(`${operation.id}: path parameter ${name} cannot serialize as an empty or dot segment`);
+		return encodeURIComponent(serialized);
+	});
+	return `${surface.prefix}${relativePath}`;
+}
+export { HTTP_V1_CREDENTIALS, HTTP_V1_CREDENTIAL_SCOPES, HTTP_V1_ERROR_CODES, HTTP_V1_METHODS, HTTP_V1_SCOPES, HTTP_V1_SURFACES, buildHttpOperationPath, defineHttpOperation, defineHttpSurface, defineResponseObject, defineSuccessResponse };