@stripe/extensibility-sdk 0.22.4

package/dist/stdlib/refs.d.ts

@@ -0,0 +1,62 @@
+import { type __brand, type __stripeType, type StripeTypeSymbol } from './brand.js';
+import type { ExtractObjectTag } from './type-utils.js';
+/**
+ * Object reference — a typed pointer to another API resource.
+ *
+ * @example
+ * ```
+ * { type: "v2.core.customer", id: "cus_1234" }
+ * ```
+ *
+ * The type parameter T must have a readonly `object` property
+ * whose string literal type becomes the `type` field's value.
+ *
+ * @discriminator :type T
+ *
+ * @public
+ */
+export type Ref<T extends {
+    readonly object: string;
+} = {
+    readonly object: string;
+}> = {
+    /** The object tag of the referenced resource (e.g., "v2.core.customer"). */
+    type: ExtractObjectTag<T>;
+    /** The ID of the referenced resource. */
+    id: string;
+} & {
+    readonly [__brand]: 'Ref';
+    readonly __type?: T;
+    readonly [__stripeType]: 'string';
+};
+/** Factory for creating {@link (Ref:type)} values from an object with `object` and `id` fields. @public */
+export declare const Ref: {
+    create: <T extends {
+        readonly object: string;
+    }>(step: T & {
+        readonly id: string;
+    }) => Ref<T>;
+};
+/**
+ * A paginated list of references to objects of type T.
+ *
+ * @public
+ */
+export type PaginatedRefList<T extends {
+    readonly object: string;
+} = {
+    readonly object: string;
+}> = Ref<T>[] & {
+    readonly [__brand]: 'PaginatedRefList';
+    readonly __type?: T;
+    readonly [__stripeType]: `list<${Ref<T>[StripeTypeSymbol]}>`;
+};
+/** Factory for creating {@link PaginatedRefList} values from an array of {@link Ref} items. @public */
+export declare const PaginatedRefList: {
+    create: <T extends {
+        readonly object: string;
+    } = {
+        readonly object: string;
+    }>(items?: Ref<T>[]) => PaginatedRefList<T>;
+};
+//# sourceMappingURL=refs.d.ts.map

package/dist/stdlib/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/stdlib/refs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,IAAI;IACrF,4EAA4E;IAC5E,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC1B,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG;IACF,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC;CACnC,CAAC;AAEF,2GAA2G;AAC3G,eAAO,MAAM,GAAG;aACL,CAAC,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,QACtC,CAAC,GAAG;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,KAChC,GAAG,CAAC,CAAC,CAAC;CAOV,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,IACjE,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG;IACb,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC;CAC9D,CAAC;AAEF,uGAAuG;AACvG,eAAO,MAAM,gBAAgB;aAClB,CAAC,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE;yBAAsB,MAAM;eACjE,GAAG,CAAC,CAAC,CAAC,EAAE,KACd,gBAAgB,CAAC,CAAC,CAAC;CAIvB,CAAC"}

package/dist/stdlib/scalars.d.ts

@@ -0,0 +1,141 @@
+import { type __integerBrand } from '@formspec/core';
+import { type __brand, type __stripeType } from './brand.js';
+/** A branded object type representing a JSON map (`map<string>`) in the Stripe type system. @public */
+export type JsonObject = object & {
+    readonly [__brand]: 'JsonObject';
+    readonly [__stripeType]: 'map<string>';
+};
+/** Factory for creating {@link JsonObject} branded values. @public */
+export declare const JsonObject: {
+    create: (value: object) => JsonObject;
+};
+/** A branded integer — a `number` guaranteed to satisfy `Number.isInteger`. @public */
+export type Integer = number & {
+    readonly [__integerBrand]: true;
+    readonly [__stripeType]: 'int';
+};
+/**
+ * Distinct brand for PositiveInteger so an Integer is not assignable to
+ * PositiveInteger without going through the guard. PositiveInteger is a
+ * subtype of Integer (it carries both brands), so it can be used wherever
+ * Integer is expected.
+ * @internal
+ */
+declare const __positiveIntegerBrand: unique symbol;
+/**
+ * A branded non-negative integer — a `number` guaranteed to be an integer ≥ 0.
+ *
+ * This is a subtype of {@link (Integer:type)}: every non-negative integer is an
+ * integer, so `PositiveInteger` values are assignable to `Integer` contexts.
+ * The reverse is not true — an `Integer` cannot be assigned where a
+ * `PositiveInteger` is expected without going through the `PositiveInteger.is()`
+ * type guard or `PositiveInteger.from()` factory.
+ *
+ * @remarks
+ * Despite the name, this type includes zero (`>= 0`, not `> 0`).
+ * The schema-level constraint `@minimum 0` should be added to fields
+ * typed as `PositiveInteger` to ensure the non-negativity invariant
+ * is enforced at validation time.
+ *
+ * @public
+ */
+export type PositiveInteger = number & {
+    readonly [__integerBrand]: true;
+    readonly [__positiveIntegerBrand]: true;
+    readonly [__stripeType]: 'int';
+};
+/**
+ * Rounding directions for coercing a number to an integer.
+ *
+ * A focused subset of {@link https://standards.ieee.org/ieee/754/6210/ | IEEE 754-2019} §4.3:
+ *
+ * | Direction      | Behavior                     | Examples (→ integer)           |
+ * | -------------- | ---------------------------- | ------------------------------ |
+ * | `'ceil'`       | Toward +∞                    | 1.1→2, -1.1→-1                |
+ * | `'floor'`      | Toward -∞                    | 1.9→1, -1.1→-2                |
+ * | `'round-down'` | Toward zero (truncate)       | 1.9→1, -1.9→-1                |
+ * | `'round-up'`   | Away from zero               | 1.1→2, -1.1→-2                |
+ * | `'half-up'`    | Nearest; ties away from zero | 0.5→1, -0.5→-1, 1.4→1         |
+ *
+ * @public
+ */
+export type IntegerRoundDirection = 'ceil' | 'floor' | 'round-down' | 'round-up' | 'half-up';
+/** Factory and type guard for {@link (Integer:type)} branded values. @public */
+export declare const Integer: {
+    /**
+     * Type guard that narrows a `number` to {@link (Integer:type)}.
+     *
+     * @example
+     * ```ts
+     * const n: number = getCount();
+     * if (Integer.is(n)) {
+     *   // n is Integer here
+     *   config.retryCount = n;
+     * }
+     * ```
+     * @public
+     */
+    is: (value: number) => value is Integer;
+    /**
+     * Coerces a number to an {@link (Integer:type)} by rounding.
+     * Throws if the value is not finite.
+     *
+     * @example
+     * ```ts
+     * const price = 9.99;
+     * const rounded = Integer.from(price, 'floor'); // 9
+     * const ceiled = Integer.from(price, 'ceil');   // 10
+     * ```
+     * @public
+     */
+    from: (value: number, rounding: IntegerRoundDirection) => Integer;
+};
+/** Factory and type guard for {@link (PositiveInteger:type)} branded values. @public */
+export declare const PositiveInteger: {
+    /**
+     * Type guard that narrows a `number` to {@link (PositiveInteger:type)}.
+     *
+     * @example
+     * ```ts
+     * const n: number = getRetryCount();
+     * if (PositiveInteger.is(n)) {
+     *   // n is PositiveInteger here
+     *   config.maxRetries = n;
+     * }
+     * ```
+     * @public
+     */
+    is: (value: number) => value is PositiveInteger;
+    /**
+     * Coerces a number to a {@link (PositiveInteger:type)} by rounding.
+     * Throws if the value is not finite or the rounded result is negative.
+     *
+     * @example
+     * ```ts
+     * const ratio = 2.7;
+     * const count = PositiveInteger.from(ratio, 'floor'); // 2
+     * ```
+     * @public
+     */
+    from: (value: number, rounding: IntegerRoundDirection) => PositiveInteger;
+};
+/** A branded string representing a street address. @public */
+export type StreetAddress = string & {
+    readonly [__brand]: 'StreetAddress';
+    readonly [__stripeType]: 'string';
+};
+/** Factory for creating {@link (StreetAddress:type)} branded values. @public */
+export declare const StreetAddress: {
+    create: (address: string) => StreetAddress;
+};
+/** A branded string representing an ISO 8601 datetime. @public */
+export type Timestamp = string & {
+    readonly [__brand]: 'Timestamp';
+    readonly [__stripeType]: 'string';
+};
+/** Factory for creating {@link (Timestamp:type)} branded values. @public */
+export declare const Timestamp: {
+    create: (value: string) => Timestamp;
+};
+export {};
+//# sourceMappingURL=scalars.d.ts.map

package/dist/stdlib/scalars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../src/stdlib/scalars.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE7D,uGAAuG;AACvG,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAChC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC;CACxC,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,UAAU;oBACL,MAAM,KAAG,UAAU;CAIpC,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAC7B,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC,CAAC;AAEF;;;;;;GAMG;AACH,OAAO,CAAC,MAAM,sBAAsB,EAAE,OAAO,MAAM,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG;IACrC,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,QAAQ,CAAC,CAAC,sBAAsB,CAAC,EAAE,IAAI,CAAC;IACxC,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,qBAAqB,GAC7B,MAAM,GACN,OAAO,GACP,YAAY,GACZ,UAAU,GACV,SAAS,CAAC;AAuBd,gFAAgF;AAChF,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;OAYG;gBACS,MAAM,KAAG,KAAK,IAAI,OAAO;IAErC;;;;;;;;;;;OAWG;kBACW,MAAM,YAAY,qBAAqB,KAAG,OAAO;CAOhE,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;OAYG;gBACS,MAAM,KAAG,KAAK,IAAI,eAAe;IAE7C;;;;;;;;;;OAUG;kBACW,MAAM,YAAY,qBAAqB,KAAG,eAAe;CAcxE,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IACnC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC;CACnC,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,aAAa;sBACN,MAAM,KAAG,aAAa;CAIzC,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAC/B,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;IAEhC,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC;CACnC,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,SAAS;oBACJ,MAAM,KAAG,SAAS;CAInC,CAAC"}

package/dist/stdlib/transform-strategies.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Concrete ApplyStrategy implementations.
+ *
+ * Three strategy constants encapsulate transformation direction:
+ *   ProtoWireToType  — proto wire → SDK (incoming)
+ *   TypeToProtoWire  — SDK → proto wire (outgoing)
+ *   JsonWireToType   — config JSON → SDK
+ */
+import { _ShapeDescriptor } from './types.js';
+import type { _JsonWireToTypeStrategy, _ProtoWireToTypeStrategy, _TypeToProtoWireStrategy } from './types.js';
+/**
+ * Strategy for transforming incoming proto wire data to SDK types.
+ *
+ * @internal
+ */
+export declare const _ProtoWireToType: _ProtoWireToTypeStrategy;
+/**
+ * Strategy for transforming outgoing SDK types to proto wire data.
+ *
+ * @internal
+ */
+export declare const _TypeToProtoWire: _TypeToProtoWireStrategy;
+/**
+ * Context values threaded into config application at runtime.
+ *
+ * The platform dispatch layer builds this from the extension context
+ * (`_configAppContextFromContext`) and passes it through the config
+ * transformer into `_applyConfig`.
+ *
+ * @internal
+ */
+export interface _ConfigApplicationContext {
+    /** ISO 8601 clock time for Billing test clocks. */
+    clockTime?: string;
+}
+/**
+ * Builds a `ConfigApplicationContext` from the raw extension context.
+ *
+ * Extracts `clockTime` when present and validates it is a string.
+ * Returns an empty context when the field is absent or ctx is not an object.
+ *
+ * @internal
+ */
+export declare function _configAppContextFromContext(ctx: unknown): _ConfigApplicationContext;
+/**
+ * Strategy for transforming JSON config data to SDK types.
+ *
+ * @internal
+ */
+export declare const _JsonWireToType: _JsonWireToTypeStrategy;
+/**
+ * Apply _ProtoWireToType to a descriptor, returning the typed SDK value.
+ * Eliminates the `as unknown as T` exit cast at call sites.
+ *
+ * @internal
+ */
+export declare function _applyIncoming<T, S extends _ProtoWireToTypeStrategy>(descriptor: _ShapeDescriptor<S, T>, inputObject: unknown): T;
+/**
+ * Apply _TypeToProtoWire to a descriptor. The input is typed as `T`,
+ * catching wrong-direction mistakes at compile time.
+ *
+ * @internal
+ */
+export declare function _applyOutgoing<T, S extends _TypeToProtoWireStrategy>(descriptor: _ShapeDescriptor<S, T>, inputObject: T): Record<string, unknown>;
+/**
+ * Apply _JsonWireToType to a config descriptor, returning the typed config value.
+ *
+ * When `appCtx` is provided and contains a `clockTime`, empty datetime fields
+ * are backfilled from the clock time instead of returning `undefined`.
+ *
+ * @internal
+ */
+export declare function _applyConfig<T, S extends _JsonWireToTypeStrategy>(descriptor: _ShapeDescriptor<S, T>, inputObject: unknown, appCtx?: _ConfigApplicationContext): T;
+//# sourceMappingURL=transform-strategies.d.ts.map

package/dist/stdlib/transform-strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-strategies.d.ts","sourceRoot":"","sources":["../../src/stdlib/transform-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,gBAAgB,EAKjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAGV,uBAAuB,EAEvB,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAmCpB;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,wBAuF9B,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,wBAuF9B,CAAC;AAMF;;;;;;;;GAQG;AACH,MAAM,WAAW,yBAAyB;IACxC,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG,yBAAyB,CAYpF;AAMD;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,uBAiE7B,CAAC;AAgJF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,wBAAwB,EAClE,UAAU,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAClC,WAAW,EAAE,OAAO,GACnB,CAAC,CAGH;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,wBAAwB,EAClE,UAAU,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAClC,WAAW,EAAE,CAAC,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,uBAAuB,EAC/D,UAAU,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAClC,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,yBAAyB,GACjC,CAAC,CAKH"}

package/dist/stdlib/transforms.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Core transform loop and primitive field transformers.
+ *
+ * `apply` drives the per-field loop: for each `FieldDescriptor` in a
+ * `ShapeDescriptor`, it delegates to `strategy.applyField`, which owns key
+ * selection and error wrapping for the given direction.
+ *
+ * The primitive transformers (`identity`, `required`, `translateDecimal`,
+ * `translateDateTime`, `translateEnum`, `translateShape`, `translateUnion`,
+ * `translateArray`, `translateMap`) are the building blocks used by generated
+ * extension code to populate `FieldDescriptor.transform`.
+ *
+ * Types (`ShapeDescriptor`, `UnionDescriptor`, `ApplyStrategy`, etc.) are in
+ * types.ts. Concrete strategy objects (`ProtoWireToType`, `TypeToProtoWire`,
+ * `JsonWireToType`) are in transform-strategies.ts.
+ */
+import type { _ApplyStrategy, _EnumSpec, _FieldTransformer, _ShapeDescriptor, _UnionDescriptor } from './types.js';
+/**
+ * Apply a strategy to a field array, transforming each field.
+ * The strategy determines direction (proto→SDK, SDK→proto, or JSON→SDK).
+ *
+ * @internal
+ */
+export declare function _apply<S extends _ApplyStrategy>(descriptor: _ShapeDescriptor<S>, strategy: S, inputObject: unknown, typeName?: string): Record<string, unknown>;
+/**
+ * Pass a value through unchanged.
+ *
+ * @internal
+ */
+export declare const _identity: _FieldTransformer;
+/**
+ * Wraps a transformer so that a `null` / `undefined` result throws
+ * `WireParseError('Required field is missing')`, which `strategy.applyField`
+ * will catch and re-throw as WireReadError / WireWriteError with field context.
+ *
+ * The inner transformer runs first, so strategies that backfill absent values
+ * (e.g. clock-aware `translateDateTime`) can satisfy the requirement.
+ *
+ * @internal
+ */
+export declare function _required(fn?: _FieldTransformer): _FieldTransformer;
+/**
+ * Translate a field using the strategy's decimal conversion.
+ *
+ * @internal
+ */
+export declare const _translateDecimal: _FieldTransformer;
+/**
+ * Translate a field using the strategy's datetime conversion.
+ *
+ * @internal
+ */
+export declare const _translateDateTime: _FieldTransformer;
+/**
+ * Create a _FieldTransformer that translates an enum value using the given spec.
+ * For bidirectional proto enums, pass a `_ProtoEnum` instance.
+ * For config validation, pass a `_ConfigEnum` instance.
+ *
+ * @internal
+ */
+export declare function _translateEnum(spec: _EnumSpec): _FieldTransformer;
+/**
+ * Create a _FieldTransformer that applies a nested _ShapeDescriptor,
+ * threading the strategy through. Returns `undefined` for null/undefined input.
+ *
+ * Accepts a factory `() => _ShapeDescriptor` rather than a descriptor directly,
+ * so that the descriptor constant is resolved lazily at call time. This allows
+ * generated descriptors to reference each other without regard to declaration
+ * order (avoiding temporal dead zone errors with `const`).
+ *
+ * @internal
+ */
+export declare function _translateShape(getDesc: () => _ShapeDescriptor): _FieldTransformer;
+/**
+ * Create a _FieldTransformer that applies a _UnionDescriptor via the strategy.
+ * Returns `undefined` for null/undefined input.
+ *
+ * Accepts a factory `() => _UnionDescriptor` rather than a descriptor directly,
+ * for the same reason as `_translateShape` — lazy resolution avoids TDZ errors
+ * when generated descriptors reference each other.
+ *
+ * @internal
+ */
+export declare function _translateUnion(getDesc: () => _UnionDescriptor): _FieldTransformer;
+/**
+ * Apply an element transform to each item in an array.
+ *
+ * @internal
+ */
+export declare function _translateArray(elementFn: _FieldTransformer): _FieldTransformer;
+/**
+ * Apply key/value transforms to every entry in a Record.
+ *
+ * @internal
+ */
+export declare function _translateMap(keyFn: _FieldTransformer, valueFn: _FieldTransformer): _FieldTransformer;
+//# sourceMappingURL=transforms.d.ts.map

package/dist/stdlib/transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.d.ts","sourceRoot":"","sources":["../../src/stdlib/transforms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAC7C,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,EACX,WAAW,EAAE,OAAO,EACpB,QAAQ,SAAsB,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8CzB;AAMD;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,iBAA+C,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,EAAE,GAAE,iBAA6B,GAAG,iBAAiB,CAQ9E;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBACE,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBACE,CAAC;AAEpC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,iBAAiB,CAEjE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,iBAAiB,CAKlF;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,iBAAiB,CAKlF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAQ/E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,iBAAiB,GACzB,iBAAiB,CAqBnB"}

package/dist/stdlib/type-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extracts the string literal type of the `object` property from T.
+ *
+ * @public
+ */
+export type ExtractObjectTag<T> = T extends {
+    readonly object: infer O;
+} ? O extends string ? O : never : never;
+//# sourceMappingURL=type-utils.d.ts.map

package/dist/stdlib/type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../../src/stdlib/type-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACpE,CAAC,SAAS,MAAM,GACd,CAAC,GACD,KAAK,GACP,KAAK,CAAC"}