@livestore/sync-s2 0.4.0 → 0.5.0-dev.0

package/dist/http-client-generated.d.ts

@@ -1,1372 +1,658 @@
-import { Effect, type HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, type ParseResult, Schema as S } from '@livestore/utils/effect';
-declare const ListAccessTokensParams_base: S.Struct<{
-    prefix: S.optionalWith<typeof S.String, {
-        nullable: true;
-        default: () => "";
-    }>;
-    start_after: S.optionalWith<typeof S.String, {
-        nullable: true;
-        default: () => "";
-    }>;
-    limit: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
-        nullable: true;
-        default: () => 1000;
-    }>;
-}>;
+import { Effect, type HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, Schema as S } from '@livestore/utils/effect';
+declare const ListAccessTokensParams_base: S.Class<ListAccessTokensParams, S.Struct<{
+    readonly prefix: S.withDecodingDefault<S.optional<S.String>, never>;
+    readonly start_after: S.withDecodingDefault<S.optional<S.String>, never>;
+    readonly limit: S.withDecodingDefault<S.optional<S.Int>, never>;
+}>, {}>;
 export declare class ListAccessTokensParams extends ListAccessTokensParams_base {
 }
-declare const ResourceSet_base: S.Union<[S.Struct<{
+export declare const ResourceSet: S.Union<readonly [S.Struct<{
     /**
      * Match only the resource with this exact name.
      * Use an empty string to match no resources.
      */
-    exact: typeof S.String;
+    readonly exact: S.String;
 }>, S.Struct<{
     /**
      * Match all resources that start with this prefix.
      * Use an empty string to match all resource.
      */
-    prefix: typeof S.String;
+    readonly prefix: S.String;
 }>]>;
-export declare class ResourceSet extends ResourceSet_base {
-}
-declare const ReadWritePermissions_base: S.Class<ReadWritePermissions, {
-    /**
-     * Read permission.
-     */
-    read: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-        default: () => false;
-    }>;
-    /**
-     * Write permission.
-     */
-    write: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-        default: () => false;
-    }>;
-}, S.Struct.Encoded<{
+declare const ReadWritePermissions_base: S.Class<ReadWritePermissions, S.Struct<{
     /**
      * Read permission.
      */
-    read: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-        default: () => false;
-    }>;
+    readonly read: S.withDecodingDefault<S.optional<S.Boolean>, never>;
     /**
      * Write permission.
      */
-    write: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-        default: () => false;
-    }>;
-}>, never, {
-    readonly read?: boolean;
-} & {
-    readonly write?: boolean;
-}, {}, {}>;
+    readonly write: S.withDecodingDefault<S.optional<S.Boolean>, never>;
+}>, {}>;
 export declare class ReadWritePermissions extends ReadWritePermissions_base {
 }
-declare const PermittedOperationGroups_base: S.Class<PermittedOperationGroups, {
-    account: S.optionalWith<typeof ReadWritePermissions, {
-        nullable: true;
-    }>;
-    basin: S.optionalWith<typeof ReadWritePermissions, {
-        nullable: true;
-    }>;
-    stream: S.optionalWith<typeof ReadWritePermissions, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    account: S.optionalWith<typeof ReadWritePermissions, {
-        nullable: true;
-    }>;
-    basin: S.optionalWith<typeof ReadWritePermissions, {
-        nullable: true;
-    }>;
-    stream: S.optionalWith<typeof ReadWritePermissions, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly account?: ReadWritePermissions | undefined;
-} & {
-    readonly basin?: ReadWritePermissions | undefined;
-} & {
-    readonly stream?: ReadWritePermissions | undefined;
-}, {}, {}>;
+declare const PermittedOperationGroups_base: S.Class<PermittedOperationGroups, S.Struct<{
+    readonly account: S.optional<S.NullOr<typeof ReadWritePermissions>>;
+    readonly basin: S.optional<S.NullOr<typeof ReadWritePermissions>>;
+    readonly stream: S.optional<S.NullOr<typeof ReadWritePermissions>>;
+}>, {}>;
 export declare class PermittedOperationGroups extends PermittedOperationGroups_base {
 }
-declare const Operation_base: S.Literal<["list-basins", "create-basin", "delete-basin", "reconfigure-basin", "get-basin-config", "issue-access-token", "revoke-access-token", "list-access-tokens", "list-streams", "create-stream", "delete-stream", "get-stream-config", "reconfigure-stream", "check-tail", "append", "read", "trim", "fence", "account-metrics", "basin-metrics", "stream-metrics"]>;
-export declare class Operation extends Operation_base {
-}
-declare const AccessTokenScope_base: S.Class<AccessTokenScope, {
-    access_tokens: S.optionalWith<typeof ResourceSet, {
-        nullable: true;
-    }>;
-    basins: S.optionalWith<typeof ResourceSet, {
-        nullable: true;
-    }>;
-    op_groups: S.optionalWith<typeof PermittedOperationGroups, {
-        nullable: true;
-    }>;
+export declare const Operation: S.Literals<readonly ["list-basins", "create-basin", "delete-basin", "reconfigure-basin", "get-basin-config", "issue-access-token", "revoke-access-token", "list-access-tokens", "list-streams", "create-stream", "delete-stream", "get-stream-config", "reconfigure-stream", "check-tail", "append", "read", "trim", "fence", "account-metrics", "basin-metrics", "stream-metrics"]>;
+declare const AccessTokenScope_base: S.Class<AccessTokenScope, S.Struct<{
+    readonly access_tokens: S.optional<S.NullOr<S.Union<readonly [S.Struct<{
+        /**
+         * Match only the resource with this exact name.
+         * Use an empty string to match no resources.
+         */
+        readonly exact: S.String;
+    }>, S.Struct<{
+        /**
+         * Match all resources that start with this prefix.
+         * Use an empty string to match all resource.
+         */
+        readonly prefix: S.String;
+    }>]>>>;
+    readonly basins: S.optional<S.NullOr<S.Union<readonly [S.Struct<{
+        /**
+         * Match only the resource with this exact name.
+         * Use an empty string to match no resources.
+         */
+        readonly exact: S.String;
+    }>, S.Struct<{
+        /**
+         * Match all resources that start with this prefix.
+         * Use an empty string to match all resource.
+         */
+        readonly prefix: S.String;
+    }>]>>>;
+    readonly op_groups: S.optional<S.NullOr<typeof PermittedOperationGroups>>;
     /**
      * Operations allowed for the token.
      * A union of allowed operations and groups is used as an effective set of allowed operations.
      */
-    ops: S.optionalWith<S.Array$<typeof Operation>, {
-        nullable: true;
-    }>;
-    streams: S.optionalWith<typeof ResourceSet, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    access_tokens: S.optionalWith<typeof ResourceSet, {
-        nullable: true;
-    }>;
-    basins: S.optionalWith<typeof ResourceSet, {
-        nullable: true;
-    }>;
-    op_groups: S.optionalWith<typeof PermittedOperationGroups, {
-        nullable: true;
-    }>;
-    /**
-     * Operations allowed for the token.
-     * A union of allowed operations and groups is used as an effective set of allowed operations.
-     */
-    ops: S.optionalWith<S.Array$<typeof Operation>, {
-        nullable: true;
-    }>;
-    streams: S.optionalWith<typeof ResourceSet, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly access_tokens?: {
-        readonly exact: string;
-    } | {
-        readonly prefix: string;
-    } | undefined;
-} & {
-    readonly basins?: {
-        readonly exact: string;
-    } | {
-        readonly prefix: string;
-    } | undefined;
-} & {
-    readonly op_groups?: PermittedOperationGroups | undefined;
-} & {
-    readonly ops?: readonly ("read" | "list-basins" | "create-basin" | "delete-basin" | "reconfigure-basin" | "get-basin-config" | "issue-access-token" | "revoke-access-token" | "list-access-tokens" | "list-streams" | "create-stream" | "delete-stream" | "get-stream-config" | "reconfigure-stream" | "check-tail" | "append" | "trim" | "fence" | "account-metrics" | "basin-metrics" | "stream-metrics")[] | undefined;
-} & {
-    readonly streams?: {
-        readonly exact: string;
-    } | {
-        readonly prefix: string;
-    } | undefined;
-}, {}, {}>;
+    readonly ops: S.optional<S.NullOr<S.$Array<S.Literals<readonly ["list-basins", "create-basin", "delete-basin", "reconfigure-basin", "get-basin-config", "issue-access-token", "revoke-access-token", "list-access-tokens", "list-streams", "create-stream", "delete-stream", "get-stream-config", "reconfigure-stream", "check-tail", "append", "read", "trim", "fence", "account-metrics", "basin-metrics", "stream-metrics"]>>>>;
+    readonly streams: S.optional<S.NullOr<S.Union<readonly [S.Struct<{
+        /**
+         * Match only the resource with this exact name.
+         * Use an empty string to match no resources.
+         */
+        readonly exact: S.String;
+    }>, S.Struct<{
+        /**
+         * Match all resources that start with this prefix.
+         * Use an empty string to match all resource.
+         */
+        readonly prefix: S.String;
+    }>]>>>;
+}>, {}>;
 export declare class AccessTokenScope extends AccessTokenScope_base {
 }
-declare const AccessTokenInfo_base: S.Class<AccessTokenInfo, {
-    /**
-     * Namespace streams based on the configured stream-level scope, which must be a prefix.
-     * Stream name arguments will be automatically prefixed, and the prefix will be stripped when listing streams.
-     */
-    auto_prefix_streams: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-        default: () => false;
-    }>;
-    /**
-     * Expiration time in ISO 8601 format.
-     * If not set, the expiration will be set to that of the requestor's token.
-     */
-    expires_at: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    /**
-     * Access token ID.
-     * It must be unique to the account and between 1 and 96 bytes in length.
-     */
-    id: typeof S.String;
-    /**
-     * Access token scope.
-     */
-    scope: typeof AccessTokenScope;
-}, S.Struct.Encoded<{
+declare const AccessTokenInfo_base: S.Class<AccessTokenInfo, S.Struct<{
     /**
      * Namespace streams based on the configured stream-level scope, which must be a prefix.
      * Stream name arguments will be automatically prefixed, and the prefix will be stripped when listing streams.
      */
-    auto_prefix_streams: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-        default: () => false;
-    }>;
+    readonly auto_prefix_streams: S.withDecodingDefault<S.optional<S.Boolean>, never>;
     /**
      * Expiration time in ISO 8601 format.
      * If not set, the expiration will be set to that of the requestor's token.
      */
-    expires_at: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
+    readonly expires_at: S.optional<S.NullOr<S.String>>;
     /**
      * Access token ID.
      * It must be unique to the account and between 1 and 96 bytes in length.
      */
-    id: typeof S.String;
+    readonly id: S.String;
     /**
      * Access token scope.
      */
-    scope: typeof AccessTokenScope;
-}>, never, {
-    readonly id: string;
-} & {
-    readonly scope: AccessTokenScope;
-} & {
-    readonly auto_prefix_streams?: boolean;
-} & {
-    readonly expires_at?: string | undefined;
-}, {}, {}>;
+    readonly scope: typeof AccessTokenScope;
+}>, {}>;
 export declare class AccessTokenInfo extends AccessTokenInfo_base {
 }
-declare const ListAccessTokensResponse_base: S.Class<ListAccessTokensResponse, {
+declare const ListAccessTokensResponse_base: S.Class<ListAccessTokensResponse, S.Struct<{
     /**
      * Matching access tokens.
      */
-    access_tokens: S.filter<S.Array$<typeof AccessTokenInfo>>;
+    readonly access_tokens: S.$Array<typeof AccessTokenInfo>;
     /**
      * Indicates that there are more access tokens that match the criteria.
      */
-    has_more: typeof S.Boolean;
-}, S.Struct.Encoded<{
-    /**
-     * Matching access tokens.
-     */
-    access_tokens: S.filter<S.Array$<typeof AccessTokenInfo>>;
-    /**
-     * Indicates that there are more access tokens that match the criteria.
-     */
-    has_more: typeof S.Boolean;
-}>, never, {
-    readonly access_tokens: readonly AccessTokenInfo[];
-} & {
-    readonly has_more: boolean;
-}, {}, {}>;
+    readonly has_more: S.Boolean;
+}>, {}>;
 export declare class ListAccessTokensResponse extends ListAccessTokensResponse_base {
 }
-declare const ErrorResponse_base: S.Class<ErrorResponse, {
-    code: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    message: typeof S.String;
-}, S.Struct.Encoded<{
-    code: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    message: typeof S.String;
-}>, never, {
-    readonly message: string;
-} & {
-    readonly code?: string | undefined;
-}, {}, {}>;
+declare const ErrorResponse_base: S.Class<ErrorResponse, S.Struct<{
+    readonly code: S.optional<S.NullOr<S.String>>;
+    readonly message: S.String;
+}>, {}>;
 export declare class ErrorResponse extends ErrorResponse_base {
 }
-declare const IssueAccessTokenResponse_base: S.Class<IssueAccessTokenResponse, {
+declare const IssueAccessTokenResponse_base: S.Class<IssueAccessTokenResponse, S.Struct<{
     /**
      * Created access token.
      */
-    access_token: typeof S.String;
-}, S.Struct.Encoded<{
-    /**
-     * Created access token.
-     */
-    access_token: typeof S.String;
-}>, never, {
-    readonly access_token: string;
-}, {}, {}>;
+    readonly access_token: S.String;
+}>, {}>;
 export declare class IssueAccessTokenResponse extends IssueAccessTokenResponse_base {
 }
-declare const ListBasinsParams_base: S.Struct<{
-    prefix: S.optionalWith<typeof S.String, {
-        nullable: true;
-        default: () => "";
-    }>;
-    start_after: S.optionalWith<typeof S.String, {
-        nullable: true;
-        default: () => "";
-    }>;
-    limit: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
-        nullable: true;
-        default: () => 1000;
-    }>;
-}>;
+declare const ListBasinsParams_base: S.Class<ListBasinsParams, S.Struct<{
+    readonly prefix: S.withDecodingDefault<S.optional<S.String>, never>;
+    readonly start_after: S.withDecodingDefault<S.optional<S.String>, never>;
+    readonly limit: S.withDecodingDefault<S.optional<S.Int>, never>;
+}>, {}>;
 export declare class ListBasinsParams extends ListBasinsParams_base {
 }
-declare const BasinScope_base: S.Literal<["aws:us-east-1"]>;
-export declare class BasinScope extends BasinScope_base {
-}
-declare const BasinState_base: S.Literal<["active", "creating", "deleting"]>;
-export declare class BasinState extends BasinState_base {
-}
-declare const BasinInfo_base: S.Class<BasinInfo, {
-    /**
-     * Basin name.
-     */
-    name: typeof S.String;
-    /**
-     * Basin scope.
-     */
-    scope: typeof BasinScope;
-    /**
-     * Basin state.
-     */
-    state: typeof BasinState;
-}, S.Struct.Encoded<{
+export declare const BasinScope: S.Literal<"aws:us-east-1">;
+export declare const BasinState: S.Literals<readonly ["active", "creating", "deleting"]>;
+declare const BasinInfo_base: S.Class<BasinInfo, S.Struct<{
     /**
      * Basin name.
      */
-    name: typeof S.String;
+    readonly name: S.String;
     /**
      * Basin scope.
      */
-    scope: typeof BasinScope;
+    readonly scope: S.Literal<"aws:us-east-1">;
     /**
      * Basin state.
      */
-    state: typeof BasinState;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly scope: "aws:us-east-1";
-} & {
-    readonly state: "active" | "creating" | "deleting";
-}, {}, {}>;
+    readonly state: S.Literals<readonly ["active", "creating", "deleting"]>;
+}>, {}>;
 export declare class BasinInfo extends BasinInfo_base {
 }
-declare const ListBasinsResponse_base: S.Class<ListBasinsResponse, {
-    /**
-     * Matching basins.
-     */
-    basins: S.filter<S.Array$<typeof BasinInfo>>;
-    /**
-     * Indicates that there are more basins that match the criteria.
-     */
-    has_more: typeof S.Boolean;
-}, S.Struct.Encoded<{
+declare const ListBasinsResponse_base: S.Class<ListBasinsResponse, S.Struct<{
     /**
      * Matching basins.
      */
-    basins: S.filter<S.Array$<typeof BasinInfo>>;
+    readonly basins: S.$Array<typeof BasinInfo>;
     /**
      * Indicates that there are more basins that match the criteria.
      */
-    has_more: typeof S.Boolean;
-}>, never, {
-    readonly basins: readonly BasinInfo[];
-} & {
-    readonly has_more: boolean;
-}, {}, {}>;
+    readonly has_more: S.Boolean;
+}>, {}>;
 export declare class ListBasinsResponse extends ListBasinsResponse_base {
 }
-declare const DeleteOnEmptyConfig_base: S.Class<DeleteOnEmptyConfig, {
+declare const DeleteOnEmptyConfig_base: S.Class<DeleteOnEmptyConfig, S.Struct<{
     /**
      * Minimum age in seconds before an empty stream can be deleted.
      * Set to 0 (default) to disable delete-on-empty (don't delete automatically).
      */
-    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    /**
-     * Minimum age in seconds before an empty stream can be deleted.
-     * Set to 0 (default) to disable delete-on-empty (don't delete automatically).
-     */
-    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly min_age_secs?: number | undefined;
-}, {}, {}>;
+    readonly min_age_secs: S.optional<S.NullOr<S.Int>>;
+}>, {}>;
 export declare class DeleteOnEmptyConfig extends DeleteOnEmptyConfig_base {
 }
-declare const InfiniteRetention_base: S.Record$<typeof S.String, typeof S.Unknown>;
-export declare class InfiniteRetention extends InfiniteRetention_base {
-}
-declare const RetentionPolicy_base: S.Union<[S.Struct<{
+export declare const InfiniteRetention: S.$Record<S.String, S.Unknown>;
+export declare const RetentionPolicy: S.Union<readonly [S.Struct<{
     /**
      * Age in seconds for automatic trimming of records older than this threshold.
      * This must be set to a value greater than 0 seconds.
      * (While S2 is in public preview, this is capped at 28 days. Let us know if you'd like the cap removed.)
      */
-    age: S.filter<typeof S.Int>;
+    readonly age: S.Int;
 }>, S.Struct<{
     /**
      * Retain records unless explicitly trimmed.
      */
-    infinite: typeof InfiniteRetention;
+    readonly infinite: S.$Record<S.String, S.Unknown>;
 }>]>;
-export declare class RetentionPolicy extends RetentionPolicy_base {
-}
-declare const StorageClass_base: S.Literal<["standard", "express"]>;
-export declare class StorageClass extends StorageClass_base {
-}
-declare const TimestampingMode_base: S.Literal<["client-prefer", "client-require", "arrival"]>;
-export declare class TimestampingMode extends TimestampingMode_base {
-}
-declare const TimestampingConfig_base: S.Class<TimestampingConfig, {
-    mode: S.optionalWith<typeof TimestampingMode, {
-        nullable: true;
-    }>;
+export declare const StorageClass: S.Literals<readonly ["standard", "express"]>;
+export declare const TimestampingMode: S.Literals<readonly ["client-prefer", "client-require", "arrival"]>;
+declare const TimestampingConfig_base: S.Class<TimestampingConfig, S.Struct<{
+    readonly mode: S.optional<S.NullOr<S.Literals<readonly ["client-prefer", "client-require", "arrival"]>>>;
     /**
      * Allow client-specified timestamps to exceed the arrival time.
      * If this is `false` or not set, client timestamps will be capped at the arrival time.
      */
-    uncapped: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    mode: S.optionalWith<typeof TimestampingMode, {
-        nullable: true;
-    }>;
-    /**
-     * Allow client-specified timestamps to exceed the arrival time.
-     * If this is `false` or not set, client timestamps will be capped at the arrival time.
-     */
-    uncapped: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly mode?: "client-prefer" | "client-require" | "arrival" | undefined;
-} & {
-    readonly uncapped?: boolean | undefined;
-}, {}, {}>;
+    readonly uncapped: S.optional<S.NullOr<S.Boolean>>;
+}>, {}>;
 export declare class TimestampingConfig extends TimestampingConfig_base {
 }
-declare const StreamConfig_base: S.Class<StreamConfig, {
-    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyConfig, {
-        nullable: true;
-    }>;
-    retention_policy: S.optionalWith<typeof RetentionPolicy, {
-        nullable: true;
-    }>;
-    storage_class: S.optionalWith<typeof StorageClass, {
-        nullable: true;
-    }>;
-    timestamping: S.optionalWith<typeof TimestampingConfig, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyConfig, {
-        nullable: true;
-    }>;
-    retention_policy: S.optionalWith<typeof RetentionPolicy, {
-        nullable: true;
-    }>;
-    storage_class: S.optionalWith<typeof StorageClass, {
-        nullable: true;
-    }>;
-    timestamping: S.optionalWith<typeof TimestampingConfig, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly delete_on_empty?: DeleteOnEmptyConfig | undefined;
-} & {
-    readonly retention_policy?: {
-        readonly age: number;
-    } | {
-        readonly infinite: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} & {
-    readonly storage_class?: "standard" | "express" | undefined;
-} & {
-    readonly timestamping?: TimestampingConfig | undefined;
-}, {}, {}>;
+declare const StreamConfig_base: S.Class<StreamConfig, S.Struct<{
+    readonly delete_on_empty: S.optional<S.NullOr<typeof DeleteOnEmptyConfig>>;
+    readonly retention_policy: S.optional<S.NullOr<S.Union<readonly [S.Struct<{
+        /**
+         * Age in seconds for automatic trimming of records older than this threshold.
+         * This must be set to a value greater than 0 seconds.
+         * (While S2 is in public preview, this is capped at 28 days. Let us know if you'd like the cap removed.)
+         */
+        readonly age: S.Int;
+    }>, S.Struct<{
+        /**
+         * Retain records unless explicitly trimmed.
+         */
+        readonly infinite: S.$Record<S.String, S.Unknown>;
+    }>]>>>;
+    readonly storage_class: S.optional<S.NullOr<S.Literals<readonly ["standard", "express"]>>>;
+    readonly timestamping: S.optional<S.NullOr<typeof TimestampingConfig>>;
+}>, {}>;
 export declare class StreamConfig extends StreamConfig_base {
 }
-declare const BasinConfig_base: S.Class<BasinConfig, {
+declare const BasinConfig_base: S.Class<BasinConfig, S.Struct<{
     /**
      * Create stream on append if it doesn't exist, using the default stream configuration.
      */
-    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
+    readonly create_stream_on_append: S.optional<S.NullOr<S.Boolean>>;
     /**
      * Create stream on read if it doesn't exist, using the default stream configuration.
      */
-    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-    default_stream_config: S.optionalWith<typeof StreamConfig, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    /**
-     * Create stream on append if it doesn't exist, using the default stream configuration.
-     */
-    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-    /**
-     * Create stream on read if it doesn't exist, using the default stream configuration.
-     */
-    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-    default_stream_config: S.optionalWith<typeof StreamConfig, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly create_stream_on_append?: boolean | undefined;
-} & {
-    readonly create_stream_on_read?: boolean | undefined;
-} & {
-    readonly default_stream_config?: StreamConfig | undefined;
-}, {}, {}>;
+    readonly create_stream_on_read: S.optional<S.NullOr<S.Boolean>>;
+    readonly default_stream_config: S.optional<S.NullOr<typeof StreamConfig>>;
+}>, {}>;
 export declare class BasinConfig extends BasinConfig_base {
 }
-declare const CreateBasinRequest_base: S.Class<CreateBasinRequest, {
+declare const CreateBasinRequest_base: S.Class<CreateBasinRequest, S.Struct<{
     /**
      * Basin name which must be globally unique.
      * It can be between 8 and 48 characters in length, and comprise lowercase letters, numbers and hyphens.
      * It cannot begin or end with a hyphen.
      */
-    basin: typeof S.String;
-    config: S.optionalWith<typeof BasinConfig, {
-        nullable: true;
-    }>;
+    readonly basin: S.String;
+    readonly config: S.optional<S.NullOr<typeof BasinConfig>>;
     /**
      * Basin scope.
      */
-    scope: S.optionalWith<typeof BasinScope, {
-        nullable: true;
-        default: () => "aws:us-east-1";
-    }>;
-}, S.Struct.Encoded<{
-    /**
-     * Basin name which must be globally unique.
-     * It can be between 8 and 48 characters in length, and comprise lowercase letters, numbers and hyphens.
-     * It cannot begin or end with a hyphen.
-     */
-    basin: typeof S.String;
-    config: S.optionalWith<typeof BasinConfig, {
-        nullable: true;
-    }>;
-    /**
-     * Basin scope.
-     */
-    scope: S.optionalWith<typeof BasinScope, {
-        nullable: true;
-        default: () => "aws:us-east-1";
-    }>;
-}>, never, {
-    readonly basin: string;
-} & {
-    readonly scope?: "aws:us-east-1";
-} & {
-    readonly config?: BasinConfig | undefined;
-}, {}, {}>;
+    readonly scope: S.withDecodingDefault<S.optional<S.Literal<"aws:us-east-1">>, never>;
+}>, {}>;
 export declare class CreateBasinRequest extends CreateBasinRequest_base {
 }
-declare const CreateOrReconfigureBasinParams_base: S.Struct<{
-    's2-request-token': S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-}>;
+declare const CreateOrReconfigureBasinParams_base: S.Class<CreateOrReconfigureBasinParams, S.Struct<{
+    readonly 's2-request-token': S.optional<S.NullOr<S.String>>;
+}>, {}>;
 export declare class CreateOrReconfigureBasinParams extends CreateOrReconfigureBasinParams_base {
 }
-declare const CreateOrReconfigureBasinRequest_base: typeof S.Null;
-export declare class CreateOrReconfigureBasinRequest extends CreateOrReconfigureBasinRequest_base {
-}
-declare const DeleteOnEmptyReconfiguration_base: S.Class<DeleteOnEmptyReconfiguration, {
+export declare const CreateOrReconfigureBasinRequest: S.Union<readonly [S.Null]>;
+declare const DeleteOnEmptyReconfiguration_base: S.Class<DeleteOnEmptyReconfiguration, S.Struct<{
     /**
      * Minimum age in seconds before an empty stream can be deleted.
      * Set to 0 to disable delete-on-empty (don't delete automatically).
      */
-    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    /**
-     * Minimum age in seconds before an empty stream can be deleted.
-     * Set to 0 to disable delete-on-empty (don't delete automatically).
-     */
-    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly min_age_secs?: number | undefined;
-}, {}, {}>;
+    readonly min_age_secs: S.optional<S.NullOr<S.Int>>;
+}>, {}>;
 export declare class DeleteOnEmptyReconfiguration extends DeleteOnEmptyReconfiguration_base {
 }
-declare const TimestampingReconfiguration_base: S.Class<TimestampingReconfiguration, {
-    mode: S.optionalWith<typeof TimestampingMode, {
-        nullable: true;
-    }>;
-    /**
-     * Allow client-specified timestamps to exceed the arrival time.
-     */
-    uncapped: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    mode: S.optionalWith<typeof TimestampingMode, {
-        nullable: true;
-    }>;
+declare const TimestampingReconfiguration_base: S.Class<TimestampingReconfiguration, S.Struct<{
+    readonly mode: S.optional<S.NullOr<S.Literals<readonly ["client-prefer", "client-require", "arrival"]>>>;
     /**
      * Allow client-specified timestamps to exceed the arrival time.
      */
-    uncapped: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly mode?: "client-prefer" | "client-require" | "arrival" | undefined;
-} & {
-    readonly uncapped?: boolean | undefined;
-}, {}, {}>;
+    readonly uncapped: S.optional<S.NullOr<S.Boolean>>;
+}>, {}>;
 export declare class TimestampingReconfiguration extends TimestampingReconfiguration_base {
 }
-declare const StreamReconfiguration_base: S.Class<StreamReconfiguration, {
-    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyReconfiguration, {
-        nullable: true;
-    }>;
-    retention_policy: S.optionalWith<typeof RetentionPolicy, {
-        nullable: true;
-    }>;
-    storage_class: S.optionalWith<typeof StorageClass, {
-        nullable: true;
-    }>;
-    timestamping: S.optionalWith<typeof TimestampingReconfiguration, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyReconfiguration, {
-        nullable: true;
-    }>;
-    retention_policy: S.optionalWith<typeof RetentionPolicy, {
-        nullable: true;
-    }>;
-    storage_class: S.optionalWith<typeof StorageClass, {
-        nullable: true;
-    }>;
-    timestamping: S.optionalWith<typeof TimestampingReconfiguration, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly delete_on_empty?: DeleteOnEmptyReconfiguration | undefined;
-} & {
-    readonly retention_policy?: {
-        readonly age: number;
-    } | {
-        readonly infinite: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} & {
-    readonly storage_class?: "standard" | "express" | undefined;
-} & {
-    readonly timestamping?: TimestampingReconfiguration | undefined;
-}, {}, {}>;
+declare const StreamReconfiguration_base: S.Class<StreamReconfiguration, S.Struct<{
+    readonly delete_on_empty: S.optional<S.NullOr<typeof DeleteOnEmptyReconfiguration>>;
+    readonly retention_policy: S.optional<S.NullOr<S.Union<readonly [S.Struct<{
+        /**
+         * Age in seconds for automatic trimming of records older than this threshold.
+         * This must be set to a value greater than 0 seconds.
+         * (While S2 is in public preview, this is capped at 28 days. Let us know if you'd like the cap removed.)
+         */
+        readonly age: S.Int;
+    }>, S.Struct<{
+        /**
+         * Retain records unless explicitly trimmed.
+         */
+        readonly infinite: S.$Record<S.String, S.Unknown>;
+    }>]>>>;
+    readonly storage_class: S.optional<S.NullOr<S.Literals<readonly ["standard", "express"]>>>;
+    readonly timestamping: S.optional<S.NullOr<typeof TimestampingReconfiguration>>;
+}>, {}>;
 export declare class StreamReconfiguration extends StreamReconfiguration_base {
 }
-declare const BasinReconfiguration_base: S.Class<BasinReconfiguration, {
-    /**
-     * Create a stream on append.
-     */
-    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-    /**
-     * Create a stream on read.
-     */
-    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-    default_stream_config: S.optionalWith<typeof StreamReconfiguration, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
+declare const BasinReconfiguration_base: S.Class<BasinReconfiguration, S.Struct<{
     /**
      * Create a stream on append.
      */
-    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
+    readonly create_stream_on_append: S.optional<S.NullOr<S.Boolean>>;
     /**
      * Create a stream on read.
      */
-    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-    default_stream_config: S.optionalWith<typeof StreamReconfiguration, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly create_stream_on_append?: boolean | undefined;
-} & {
-    readonly create_stream_on_read?: boolean | undefined;
-} & {
-    readonly default_stream_config?: StreamReconfiguration | undefined;
-}, {}, {}>;
+    readonly create_stream_on_read: S.optional<S.NullOr<S.Boolean>>;
+    readonly default_stream_config: S.optional<S.NullOr<typeof StreamReconfiguration>>;
+}>, {}>;
 export declare class BasinReconfiguration extends BasinReconfiguration_base {
 }
-declare const AccountMetricSet_base: S.Literal<["active-basins", "account-ops"]>;
-export declare class AccountMetricSet extends AccountMetricSet_base {
-}
-declare const TimeseriesInterval_base: S.Literal<["minute", "hour", "day"]>;
-export declare class TimeseriesInterval extends TimeseriesInterval_base {
-}
-declare const AccountMetricsParams_base: S.Struct<{
-    set: typeof AccountMetricSet;
-    start: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    end: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    interval: S.optionalWith<typeof TimeseriesInterval, {
-        nullable: true;
-    }>;
-}>;
+export declare const AccountMetricSet: S.Literals<readonly ["active-basins", "account-ops"]>;
+export declare const TimeseriesInterval: S.Literals<readonly ["minute", "hour", "day"]>;
+declare const AccountMetricsParams_base: S.Class<AccountMetricsParams, S.Struct<{
+    readonly set: S.Literals<readonly ["active-basins", "account-ops"]>;
+    readonly start: S.optional<S.NullOr<S.Int>>;
+    readonly end: S.optional<S.NullOr<S.Int>>;
+    readonly interval: S.optional<S.NullOr<S.Literals<readonly ["minute", "hour", "day"]>>>;
+}>, {}>;
 export declare class AccountMetricsParams extends AccountMetricsParams_base {
 }
-declare const MetricUnit_base: S.Literal<["bytes", "operations"]>;
-export declare class MetricUnit extends MetricUnit_base {
-}
-declare const Scalar_base: S.Class<Scalar, {
+export declare const MetricUnit: S.Literals<readonly ["bytes", "operations"]>;
+declare const Scalar_base: S.Class<Scalar, S.Struct<{
     /**
      * Metric name.
      */
-    name: typeof S.String;
+    readonly name: S.String;
     /**
      * Unit of the metric.
      */
-    unit: typeof MetricUnit;
+    readonly unit: S.Literals<readonly ["bytes", "operations"]>;
     /**
      * Metric value.
      */
-    value: typeof S.Number;
-}, S.Struct.Encoded<{
-    /**
-     * Metric name.
-     */
-    name: typeof S.String;
-    /**
-     * Unit of the metric.
-     */
-    unit: typeof MetricUnit;
-    /**
-     * Metric value.
-     */
-    value: typeof S.Number;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly value: number;
-} & {
-    readonly unit: "bytes" | "operations";
-}, {}, {}>;
+    readonly value: S.Number;
+}>, {}>;
 export declare class Scalar extends Scalar_base {
 }
-declare const Accumulation_base: S.Class<Accumulation, {
-    /**
-     * The duration of bucket for the accumulation.
-     */
-    bucket_length: typeof TimeseriesInterval;
-    /**
-     * Timeseries name.
-     */
-    name: typeof S.String;
-    /**
-     * Unit of the metric.
-     */
-    unit: typeof MetricUnit;
-}, S.Struct.Encoded<{
+declare const Accumulation_base: S.Class<Accumulation, S.Struct<{
     /**
      * The duration of bucket for the accumulation.
      */
-    bucket_length: typeof TimeseriesInterval;
+    readonly bucket_length: S.Literals<readonly ["minute", "hour", "day"]>;
     /**
      * Timeseries name.
      */
-    name: typeof S.String;
+    readonly name: S.String;
     /**
      * Unit of the metric.
      */
-    unit: typeof MetricUnit;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly unit: "bytes" | "operations";
-} & {
-    readonly bucket_length: "minute" | "hour" | "day";
-}, {}, {}>;
+    readonly unit: S.Literals<readonly ["bytes", "operations"]>;
+}>, {}>;
 export declare class Accumulation extends Accumulation_base {
 }
-declare const Gauge_base: S.Class<Gauge, {
-    /**
-     * Timeseries name.
-     */
-    name: typeof S.String;
-    /**
-     * Unit of the metric.
-     */
-    unit: typeof MetricUnit;
-}, S.Struct.Encoded<{
+declare const Gauge_base: S.Class<Gauge, S.Struct<{
     /**
      * Timeseries name.
      */
-    name: typeof S.String;
+    readonly name: S.String;
     /**
      * Unit of the metric.
      */
-    unit: typeof MetricUnit;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly unit: "bytes" | "operations";
-}, {}, {}>;
+    readonly unit: S.Literals<readonly ["bytes", "operations"]>;
+}>, {}>;
 export declare class Gauge extends Gauge_base {
 }
-declare const Label_base: S.Class<Label, {
+declare const Label_base: S.Class<Label, S.Struct<{
     /**
      * Label name.
      */
-    name: typeof S.String;
+    readonly name: S.String;
     /**
      * Label values.
      */
-    values: S.Array$<typeof S.String>;
-}, S.Struct.Encoded<{
-    /**
-     * Label name.
-     */
-    name: typeof S.String;
-    /**
-     * Label values.
-     */
-    values: S.Array$<typeof S.String>;
-}>, never, {
-    readonly values: readonly string[];
-} & {
-    readonly name: string;
-}, {}, {}>;
+    readonly values: S.$Array<S.String>;
+}>, {}>;
 export declare class Label extends Label_base {
 }
-declare const Metric_base: S.Union<[S.Struct<{
+export declare const Metric: S.Union<readonly [S.Struct<{
     /**
      * Single named value.
      */
-    scalar: typeof Scalar;
+    readonly scalar: typeof Scalar;
 }>, S.Struct<{
     /**
      * Named series of `(timestamp, value)` points representing an accumulation over a specified
      * bucket.
      */
-    accumulation: typeof Accumulation;
+    readonly accumulation: typeof Accumulation;
 }>, S.Struct<{
     /**
      * Named series of `(timestamp, value)` points each representing an instantaneous value.
      */
-    gauge: typeof Gauge;
+    readonly gauge: typeof Gauge;
 }>, S.Struct<{
     /**
      * Set of string labels.
      */
-    label: typeof Label;
+    readonly label: typeof Label;
 }>]>;
-export declare class Metric extends Metric_base {
-}
-declare const MetricSetResponse_base: S.Class<MetricSetResponse, {
+declare const MetricSetResponse_base: S.Class<MetricSetResponse, S.Struct<{
     /**
      * Metrics comprising the set.
      */
-    values: S.Array$<typeof Metric>;
-}, S.Struct.Encoded<{
-    /**
-     * Metrics comprising the set.
-     */
-    values: S.Array$<typeof Metric>;
-}>, never, {
-    readonly values: readonly ({
-        readonly scalar: Scalar;
-    } | {
-        readonly accumulation: Accumulation;
-    } | {
-        readonly gauge: Gauge;
-    } | {
-        readonly label: Label;
-    })[];
-}, {}, {}>;
+    readonly values: S.$Array<S.Union<readonly [S.Struct<{
+        /**
+         * Single named value.
+         */
+        readonly scalar: typeof Scalar;
+    }>, S.Struct<{
+        /**
+         * Named series of `(timestamp, value)` points representing an accumulation over a specified
+         * bucket.
+         */
+        readonly accumulation: typeof Accumulation;
+    }>, S.Struct<{
+        /**
+         * Named series of `(timestamp, value)` points each representing an instantaneous value.
+         */
+        readonly gauge: typeof Gauge;
+    }>, S.Struct<{
+        /**
+         * Set of string labels.
+         */
+        readonly label: typeof Label;
+    }>]>>;
+}>, {}>;
 export declare class MetricSetResponse extends MetricSetResponse_base {
 }
-declare const BasinMetricSet_base: S.Literal<["storage", "append-ops", "read-ops", "read-throughput", "append-throughput", "basin-ops"]>;
-export declare class BasinMetricSet extends BasinMetricSet_base {
-}
-declare const BasinMetricsParams_base: S.Struct<{
-    set: typeof BasinMetricSet;
-    start: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    end: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    interval: S.optionalWith<typeof TimeseriesInterval, {
-        nullable: true;
-    }>;
-}>;
+export declare const BasinMetricSet: S.Literals<readonly ["storage", "append-ops", "read-ops", "read-throughput", "append-throughput", "basin-ops"]>;
+declare const BasinMetricsParams_base: S.Class<BasinMetricsParams, S.Struct<{
+    readonly set: S.Literals<readonly ["storage", "append-ops", "read-ops", "read-throughput", "append-throughput", "basin-ops"]>;
+    readonly start: S.optional<S.NullOr<S.Int>>;
+    readonly end: S.optional<S.NullOr<S.Int>>;
+    readonly interval: S.optional<S.NullOr<S.Literals<readonly ["minute", "hour", "day"]>>>;
+}>, {}>;
 export declare class BasinMetricsParams extends BasinMetricsParams_base {
 }
-declare const StreamMetricSet_base: S.Literal<["storage"]>;
-export declare class StreamMetricSet extends StreamMetricSet_base {
-}
-declare const StreamMetricsParams_base: S.Struct<{
-    set: typeof StreamMetricSet;
-    start: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    end: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    interval: S.optionalWith<typeof TimeseriesInterval, {
-        nullable: true;
-    }>;
-}>;
+export declare const StreamMetricSet: S.Literal<"storage">;
+declare const StreamMetricsParams_base: S.Class<StreamMetricsParams, S.Struct<{
+    readonly set: S.Literal<"storage">;
+    readonly start: S.optional<S.NullOr<S.Int>>;
+    readonly end: S.optional<S.NullOr<S.Int>>;
+    readonly interval: S.optional<S.NullOr<S.Literals<readonly ["minute", "hour", "day"]>>>;
+}>, {}>;
 export declare class StreamMetricsParams extends StreamMetricsParams_base {
 }
-declare const ListStreamsParams_base: S.Struct<{
-    prefix: S.optionalWith<typeof S.String, {
-        nullable: true;
-        default: () => "";
-    }>;
-    start_after: S.optionalWith<typeof S.String, {
-        nullable: true;
-        default: () => "";
-    }>;
-    limit: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
-        nullable: true;
-        default: () => 1000;
-    }>;
-}>;
+declare const ListStreamsParams_base: S.Class<ListStreamsParams, S.Struct<{
+    readonly prefix: S.withDecodingDefault<S.optional<S.String>, never>;
+    readonly start_after: S.withDecodingDefault<S.optional<S.String>, never>;
+    readonly limit: S.withDecodingDefault<S.optional<S.Int>, never>;
+}>, {}>;
 export declare class ListStreamsParams extends ListStreamsParams_base {
 }
-declare const StreamInfo_base: S.Class<StreamInfo, {
+declare const StreamInfo_base: S.Class<StreamInfo, S.Struct<{
     /**
      * Creation time in ISO 8601 format.
      */
-    created_at: typeof S.String;
+    readonly created_at: S.String;
     /**
      * Deletion time in ISO 8601 format, if the stream is being deleted.
      */
-    deleted_at: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
+    readonly deleted_at: S.optional<S.NullOr<S.String>>;
     /**
      * Stream name.
      */
-    name: typeof S.String;
-}, S.Struct.Encoded<{
-    /**
-     * Creation time in ISO 8601 format.
-     */
-    created_at: typeof S.String;
-    /**
-     * Deletion time in ISO 8601 format, if the stream is being deleted.
-     */
-    deleted_at: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    /**
-     * Stream name.
-     */
-    name: typeof S.String;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly created_at: string;
-} & {
-    readonly deleted_at?: string | undefined;
-}, {}, {}>;
+    readonly name: S.String;
+}>, {}>;
 export declare class StreamInfo extends StreamInfo_base {
 }
-declare const ListStreamsResponse_base: S.Class<ListStreamsResponse, {
-    /**
-     * Indicates that there are more results that match the criteria.
-     */
-    has_more: typeof S.Boolean;
-    /**
-     * Matching streams.
-     */
-    streams: S.filter<S.Array$<typeof StreamInfo>>;
-}, S.Struct.Encoded<{
+declare const ListStreamsResponse_base: S.Class<ListStreamsResponse, S.Struct<{
     /**
      * Indicates that there are more results that match the criteria.
      */
-    has_more: typeof S.Boolean;
+    readonly has_more: S.Boolean;
     /**
      * Matching streams.
      */
-    streams: S.filter<S.Array$<typeof StreamInfo>>;
-}>, never, {
-    readonly streams: readonly StreamInfo[];
-} & {
-    readonly has_more: boolean;
-}, {}, {}>;
+    readonly streams: S.$Array<typeof StreamInfo>;
+}>, {}>;
 export declare class ListStreamsResponse extends ListStreamsResponse_base {
 }
-declare const CreateStreamRequest_base: S.Class<CreateStreamRequest, {
-    config: S.optionalWith<typeof StreamConfig, {
-        nullable: true;
-    }>;
+declare const CreateStreamRequest_base: S.Class<CreateStreamRequest, S.Struct<{
+    readonly config: S.optional<S.NullOr<typeof StreamConfig>>;
     /**
      * Stream name that is unique to the basin.
      * It can be between 1 and 512 bytes in length.
      */
-    stream: typeof S.String;
-}, S.Struct.Encoded<{
-    config: S.optionalWith<typeof StreamConfig, {
-        nullable: true;
-    }>;
-    /**
-     * Stream name that is unique to the basin.
-     * It can be between 1 and 512 bytes in length.
-     */
-    stream: typeof S.String;
-}>, never, {
-    readonly stream: string;
-} & {
-    readonly config?: StreamConfig | undefined;
-}, {}, {}>;
+    readonly stream: S.String;
+}>, {}>;
 export declare class CreateStreamRequest extends CreateStreamRequest_base {
 }
-declare const CreateOrReconfigureStreamParams_base: S.Struct<{
-    's2-request-token': S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-}>;
+declare const CreateOrReconfigureStreamParams_base: S.Class<CreateOrReconfigureStreamParams, S.Struct<{
+    readonly 's2-request-token': S.optional<S.NullOr<S.String>>;
+}>, {}>;
 export declare class CreateOrReconfigureStreamParams extends CreateOrReconfigureStreamParams_base {
 }
-declare const CreateOrReconfigureStreamRequest_base: S.Union<[typeof S.Null, typeof StreamConfig]>;
-export declare class CreateOrReconfigureStreamRequest extends CreateOrReconfigureStreamRequest_base {
-}
-declare const S2Format_base: S.Literal<["raw", "base64"]>;
-export declare class S2Format extends S2Format_base {
-}
-declare const U64_base: S.filter<typeof S.Int>;
-export declare class U64 extends U64_base {
-}
-declare const ReadParams_base: S.Struct<{
-    's2-format': S.optionalWith<typeof S2Format, {
-        nullable: true;
-    }>;
-    seq_num: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
-    timestamp: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
-    tail_offset: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    count: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    bytes: S.optionalWith<S.filter<typeof S.Int>, {
-        nullable: true;
-    }>;
-    until: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
-    clamp: S.optionalWith<typeof S.Boolean, {
-        nullable: true;
-    }>;
-}>;
+export declare const CreateOrReconfigureStreamRequest: S.Union<readonly [S.Null, typeof StreamConfig]>;
+export declare const S2Format: S.Literals<readonly ["raw", "base64"]>;
+export declare const U64: S.Int;
+declare const ReadParams_base: S.Class<ReadParams, S.Struct<{
+    readonly 's2-format': S.optional<S.NullOr<S.Literals<readonly ["raw", "base64"]>>>;
+    readonly seq_num: S.optional<S.NullOr<S.Int>>;
+    readonly timestamp: S.optional<S.NullOr<S.Int>>;
+    readonly tail_offset: S.optional<S.NullOr<S.Int>>;
+    readonly count: S.optional<S.NullOr<S.Int>>;
+    readonly bytes: S.optional<S.NullOr<S.Int>>;
+    readonly until: S.optional<S.NullOr<S.Int>>;
+    readonly clamp: S.optional<S.NullOr<S.Boolean>>;
+}>, {}>;
 export declare class ReadParams extends ReadParams_base {
 }
-declare const Header_base: S.filter<S.filter<S.NonEmptyArray<typeof S.String>>>;
 /**
  * Headers add structured information to a record as name-value pairs.
  *
  * The name cannot be empty, with the exception of an S2 command record.
  */
-export declare class Header extends Header_base {
-}
-declare const SequencedRecord_base: S.Class<SequencedRecord, {
-    /**
-     * Body of the record.
-     */
-    body: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    /**
-     * Series of name-value pairs for this record.
-     */
-    headers: S.optionalWith<S.Array$<typeof Header>, {
-        nullable: true;
-    }>;
-    /**
-     * Sequence number assigned by the service.
-     */
-    seq_num: typeof U64;
-    /**
-     * Timestamp for this record.
-     */
-    timestamp: typeof U64;
-}, S.Struct.Encoded<{
+export declare const Header: S.NonEmptyArray<S.String>;
+declare const SequencedRecord_base: S.Class<SequencedRecord, S.Struct<{
     /**
      * Body of the record.
      */
-    body: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
+    readonly body: S.optional<S.NullOr<S.String>>;
     /**
      * Series of name-value pairs for this record.
      */
-    headers: S.optionalWith<S.Array$<typeof Header>, {
-        nullable: true;
-    }>;
+    readonly headers: S.optional<S.NullOr<S.$Array<S.NonEmptyArray<S.String>>>>;
     /**
      * Sequence number assigned by the service.
      */
-    seq_num: typeof U64;
+    readonly seq_num: S.Int;
     /**
      * Timestamp for this record.
      */
-    timestamp: typeof U64;
-}>, never, {
-    readonly seq_num: number;
-} & {
-    readonly timestamp: number;
-} & {
-    readonly body?: string | undefined;
-} & {
-    readonly headers?: readonly (readonly [string, ...string[]])[] | undefined;
-}, {}, {}>;
+    readonly timestamp: S.Int;
+}>, {}>;
 /**
  * Record that is durably sequenced on a stream.
  */
 export declare class SequencedRecord extends SequencedRecord_base {
 }
-declare const StreamPosition_base: S.Class<StreamPosition, {
+declare const StreamPosition_base: S.Class<StreamPosition, S.Struct<{
     /**
      * Sequence number assigned by the service.
      */
-    seq_num: S.filter<typeof S.Int>;
+    readonly seq_num: S.Int;
     /**
      * Timestamp, which may be client-specified or assigned by the service.
      * If it is assigned by the service, it will represent milliseconds since Unix epoch.
      */
-    timestamp: S.filter<typeof S.Int>;
-}, S.Struct.Encoded<{
-    /**
-     * Sequence number assigned by the service.
-     */
-    seq_num: S.filter<typeof S.Int>;
-    /**
-     * Timestamp, which may be client-specified or assigned by the service.
-     * If it is assigned by the service, it will represent milliseconds since Unix epoch.
-     */
-    timestamp: S.filter<typeof S.Int>;
-}>, never, {
-    readonly seq_num: number;
-} & {
-    readonly timestamp: number;
-}, {}, {}>;
+    readonly timestamp: S.Int;
+}>, {}>;
 /**
  * Position of a record in a stream.
  */
 export declare class StreamPosition extends StreamPosition_base {
 }
-declare const ReadBatch_base: S.Class<ReadBatch, {
+declare const ReadBatch_base: S.Class<ReadBatch, S.Struct<{
     /**
      * Records that are durably sequenced on the stream, retrieved based on the requested criteria.
      * This can only be empty in response to a regular (non-SSE) read, if the request cannot be satisfied without violating an explicit limit.
      */
-    records: S.Array$<typeof SequencedRecord>;
-    tail: S.optionalWith<typeof StreamPosition, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    /**
-     * Records that are durably sequenced on the stream, retrieved based on the requested criteria.
-     * This can only be empty in response to a regular (non-SSE) read, if the request cannot be satisfied without violating an explicit limit.
-     */
-    records: S.Array$<typeof SequencedRecord>;
-    tail: S.optionalWith<typeof StreamPosition, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly records: readonly SequencedRecord[];
-} & {
-    readonly tail?: StreamPosition | undefined;
-}, {}, {}>;
+    readonly records: S.$Array<typeof SequencedRecord>;
+    readonly tail: S.optional<S.NullOr<typeof StreamPosition>>;
+}>, {}>;
 export declare class ReadBatch extends ReadBatch_base {
 }
-declare const TailResponse_base: S.Class<TailResponse, {
+declare const TailResponse_base: S.Class<TailResponse, S.Struct<{
     /**
      * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record.
      */
-    tail: typeof StreamPosition;
-}, S.Struct.Encoded<{
-    /**
-     * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record.
-     */
-    tail: typeof StreamPosition;
-}>, never, {
-    readonly tail: StreamPosition;
-}, {}, {}>;
+    readonly tail: typeof StreamPosition;
+}>, {}>;
 export declare class TailResponse extends TailResponse_base {
 }
-declare const AppendParams_base: S.Struct<{
-    's2-format': S.optionalWith<typeof S2Format, {
-        nullable: true;
-    }>;
-}>;
+declare const AppendParams_base: S.Class<AppendParams, S.Struct<{
+    readonly 's2-format': S.optional<S.NullOr<S.Literals<readonly ["raw", "base64"]>>>;
+}>, {}>;
 export declare class AppendParams extends AppendParams_base {
 }
-declare const AppendRecord_base: S.Class<AppendRecord, {
+declare const AppendRecord_base: S.Class<AppendRecord, S.Struct<{
     /**
      * Body of the record.
      */
-    body: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
+    readonly body: S.optional<S.NullOr<S.String>>;
     /**
      * Series of name-value pairs for this record.
      */
-    headers: S.optionalWith<S.Array$<typeof Header>, {
-        nullable: true;
-    }>;
-    timestamp: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    /**
-     * Body of the record.
-     */
-    body: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    /**
-     * Series of name-value pairs for this record.
-     */
-    headers: S.optionalWith<S.Array$<typeof Header>, {
-        nullable: true;
-    }>;
-    timestamp: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly timestamp?: number | undefined;
-} & {
-    readonly body?: string | undefined;
-} & {
-    readonly headers?: readonly (readonly [string, ...string[]])[] | undefined;
-}, {}, {}>;
+    readonly headers: S.optional<S.NullOr<S.$Array<S.NonEmptyArray<S.String>>>>;
+    readonly timestamp: S.optional<S.NullOr<S.Int>>;
+}>, {}>;
 /**
  * Record to be appended to a stream.
  */
 export declare class AppendRecord extends AppendRecord_base {
 }
-declare const AppendInput_base: S.Class<AppendInput, {
+declare const AppendInput_base: S.Class<AppendInput, S.Struct<{
     /**
      * Enforce a fencing token, which starts out as an empty string that can be overridden by a `fence` command record.
      */
-    fencing_token: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    match_seq_num: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
+    readonly fencing_token: S.optional<S.NullOr<S.String>>;
+    readonly match_seq_num: S.optional<S.NullOr<S.Int>>;
     /**
      * Batch of records to append atomically, which must contain at least one record, and no more than 1000.
      * The total size of a batch of records may not exceed 1 MiB of metered bytes.
      */
-    records: S.Array$<typeof AppendRecord>;
-}, S.Struct.Encoded<{
-    /**
-     * Enforce a fencing token, which starts out as an empty string that can be overridden by a `fence` command record.
-     */
-    fencing_token: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    match_seq_num: S.optionalWith<typeof U64, {
-        nullable: true;
-    }>;
-    /**
-     * Batch of records to append atomically, which must contain at least one record, and no more than 1000.
-     * The total size of a batch of records may not exceed 1 MiB of metered bytes.
-     */
-    records: S.Array$<typeof AppendRecord>;
-}>, never, {
-    readonly records: readonly AppendRecord[];
-} & {
-    readonly fencing_token?: string | undefined;
-} & {
-    readonly match_seq_num?: number | undefined;
-}, {}, {}>;
+    readonly records: S.$Array<typeof AppendRecord>;
+}>, {}>;
 /**
  * Payload of an `append` request.
  */
 export declare class AppendInput extends AppendInput_base {
 }
-declare const AppendAck_base: S.Class<AppendAck, {
-    /**
-     * Sequence number of the last record that was appended `+ 1`, and timestamp of the last record that was appended.
-     * The difference between `end.seq_num` and `start.seq_num` will be the number of records appended.
-     */
-    end: typeof StreamPosition;
-    /**
-     * Sequence number and timestamp of the first record that was appended.
-     */
-    start: typeof StreamPosition;
-    /**
-     * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record on the stream.
-     * This can be greater than the `end` position in case of concurrent appends.
-     */
-    tail: typeof StreamPosition;
-}, S.Struct.Encoded<{
+declare const AppendAck_base: S.Class<AppendAck, S.Struct<{
     /**
      * Sequence number of the last record that was appended `+ 1`, and timestamp of the last record that was appended.
      * The difference between `end.seq_num` and `start.seq_num` will be the number of records appended.
      */
-    end: typeof StreamPosition;
+    readonly end: typeof StreamPosition;
     /**
      * Sequence number and timestamp of the first record that was appended.
      */
-    start: typeof StreamPosition;
+    readonly start: typeof StreamPosition;
     /**
      * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record on the stream.
      * This can be greater than the `end` position in case of concurrent appends.
      */
-    tail: typeof StreamPosition;
-}>, never, {
-    readonly start: StreamPosition;
-} & {
-    readonly end: StreamPosition;
-} & {
-    readonly tail: StreamPosition;
-}, {}, {}>;
+    readonly tail: typeof StreamPosition;
+}>, {}>;
 /**
  * Success response to an `append` request.
  */
 export declare class AppendAck extends AppendAck_base {
 }
-declare const AppendConditionFailed_base: S.Union<[S.Struct<{
+/**
+ * Aborted due to a failed condition.
+ */
+export declare const AppendConditionFailed: S.Union<readonly [S.Struct<{
     /**
      * Fencing token did not match.
      * The expected fencing token is returned.
      */
-    fencing_token_mismatch: typeof S.String;
+    readonly fencing_token_mismatch: S.String;
 }>, S.Struct<{
     /**
      * Sequence number did not match the tail of the stream.
      * The expected next sequence number is returned.
      */
-    seq_num_mismatch: S.filter<typeof S.Int>;
+    readonly seq_num_mismatch: S.Int;
 }>]>;
-/**
- * Aborted due to a failed condition.
- */
-export declare class AppendConditionFailed extends AppendConditionFailed_base {
-}
 export declare const make: (httpClient: HttpClient.HttpClient, options?: {
     readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
 }) => Client;
@@ -1375,96 +661,96 @@ export interface Client {
     /**
      * List access tokens.
      */
-    readonly listAccessTokens: (options?: typeof ListAccessTokensParams.Encoded) => Effect.Effect<typeof ListAccessTokensResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly listAccessTokens: (options?: typeof ListAccessTokensParams.Encoded) => Effect.Effect<typeof ListAccessTokensResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Issue a new access token.
      */
-    readonly issueAccessToken: (options: typeof AccessTokenInfo.Encoded) => Effect.Effect<typeof IssueAccessTokenResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly issueAccessToken: (options: typeof AccessTokenInfo.Encoded) => Effect.Effect<typeof IssueAccessTokenResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Revoke an access token.
      */
-    readonly revokeAccessToken: (id: string) => Effect.Effect<void, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly revokeAccessToken: (id: string) => Effect.Effect<void, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * List basins.
      */
-    readonly listBasins: (options?: typeof ListBasinsParams.Encoded) => Effect.Effect<typeof ListBasinsResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly listBasins: (options?: typeof ListBasinsParams.Encoded) => Effect.Effect<typeof ListBasinsResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Create a basin.
      */
-    readonly createBasin: (options: typeof CreateBasinRequest.Encoded) => Effect.Effect<typeof BasinInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly createBasin: (options: typeof CreateBasinRequest.Encoded) => Effect.Effect<typeof BasinInfo.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Get basin configuration.
      */
-    readonly getBasinConfig: (basin: string) => Effect.Effect<typeof BasinConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly getBasinConfig: (basin: string) => Effect.Effect<typeof BasinConfig.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Create or reconfigure a basin.
      */
     readonly createOrReconfigureBasin: (basin: string, options: {
         readonly params?: typeof CreateOrReconfigureBasinParams.Encoded | undefined;
         readonly payload: typeof CreateOrReconfigureBasinRequest.Encoded;
-    }) => Effect.Effect<typeof BasinInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    }) => Effect.Effect<typeof BasinInfo.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Delete a basin.
      */
-    readonly deleteBasin: (basin: string) => Effect.Effect<void, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly deleteBasin: (basin: string) => Effect.Effect<void, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Reconfigure a basin.
      */
-    readonly reconfigureBasin: (basin: string, options: typeof BasinReconfiguration.Encoded) => Effect.Effect<typeof BasinConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly reconfigureBasin: (basin: string, options: typeof BasinReconfiguration.Encoded) => Effect.Effect<typeof BasinConfig.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Account-level metrics.
      */
-    readonly accountMetrics: (options: typeof AccountMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly accountMetrics: (options: typeof AccountMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Basin-level metrics.
      */
-    readonly basinMetrics: (basin: string, options: typeof BasinMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly basinMetrics: (basin: string, options: typeof BasinMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Stream-level metrics.
      */
-    readonly streamMetrics: (basin: string, stream: string, options: typeof StreamMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly streamMetrics: (basin: string, stream: string, options: typeof StreamMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * List streams.
      */
-    readonly listStreams: (options?: typeof ListStreamsParams.Encoded) => Effect.Effect<typeof ListStreamsResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly listStreams: (options?: typeof ListStreamsParams.Encoded) => Effect.Effect<typeof ListStreamsResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Create a stream.
      */
-    readonly createStream: (options: typeof CreateStreamRequest.Encoded) => Effect.Effect<typeof StreamInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly createStream: (options: typeof CreateStreamRequest.Encoded) => Effect.Effect<typeof StreamInfo.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Get stream configuration.
      */
-    readonly getStreamConfig: (stream: string) => Effect.Effect<typeof StreamConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly getStreamConfig: (stream: string) => Effect.Effect<typeof StreamConfig.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Create or reconfigure a stream.
      */
     readonly createOrReconfigureStream: (stream: string, options: {
         readonly params?: typeof CreateOrReconfigureStreamParams.Encoded | undefined;
         readonly payload: typeof CreateOrReconfigureStreamRequest.Encoded;
-    }) => Effect.Effect<typeof StreamInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    }) => Effect.Effect<typeof StreamInfo.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Delete a stream.
      */
-    readonly deleteStream: (stream: string) => Effect.Effect<void, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly deleteStream: (stream: string) => Effect.Effect<void, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Reconfigure a stream.
      */
-    readonly reconfigureStream: (stream: string, options: typeof StreamReconfiguration.Encoded) => Effect.Effect<typeof StreamConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly reconfigureStream: (stream: string, options: typeof StreamReconfiguration.Encoded) => Effect.Effect<typeof StreamConfig.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
     /**
      * Read records.
      */
-    readonly read: (stream: string, options?: typeof ReadParams.Encoded) => Effect.Effect<typeof ReadBatch.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'TailResponse', typeof TailResponse.Type>>;
+    readonly read: (stream: string, options?: typeof ReadParams.Encoded) => Effect.Effect<typeof ReadBatch.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'TailResponse', typeof TailResponse.Type>>;
     /**
      * Append records.
      */
     readonly append: (stream: string, options: {
         readonly params?: typeof AppendParams.Encoded | undefined;
         readonly payload: typeof AppendInput.Encoded;
-    }) => Effect.Effect<typeof AppendAck.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'AppendConditionFailed', typeof AppendConditionFailed.Type>>;
+    }) => Effect.Effect<typeof AppendAck.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'AppendConditionFailed', typeof AppendConditionFailed.Type>>;
     /**
      * Check the tail.
      */
-    readonly checkTail: (stream: string) => Effect.Effect<typeof TailResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    readonly checkTail: (stream: string) => Effect.Effect<typeof TailResponse.Type, HttpClientError.HttpClientError | S.SchemaError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
 }
 export interface ClientError<Tag extends string, E> {
     readonly _tag: Tag;