// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  appProtocol: "app_protocol",
  certVerificationMode: "cert_verification_mode",
  createdAt: "created_at",
  httpPort: "http_port",
  httpsPort: "https_port",
  perPage: "per_page",
  resolverIps: "resolver_ips",
  resolverNetwork: "resolver_network",
  resultInfo: "result_info",
  serviceId: "service_id",
  tcpPort: "tcp_port",
  tlsSettings: "tls_settings",
  totalCount: "total_count",
  tunnelId: "tunnel_id",
  updatedAt: "updated_at",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class VpcServiceNameAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<VpcServiceNameAlreadyExists>()(
      "VpcServiceNameAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 5101, message: { includes: "already exists" } }],
  ) {}

export class VpcServiceNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<VpcServiceNotFound>()("VpcServiceNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 5104 }],
  ) {}

export class VpcTunnelNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<VpcTunnelNotFound>()("VpcTunnelNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 5101, message: { includes: "Tunnel ID Not Found" } }],
  ) {}

export interface DirectoryServicesCreateRequestHostInfraIPv4HostNetwork {
  tunnelId: string;
}
export const DirectoryServicesCreateRequestHostInfraIPv4HostNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
    }),
  ).annotate({
    identifier: "DirectoryServicesCreateRequestHostInfraIPv4HostNetwork",
  }) as any as S.Schema<DirectoryServicesCreateRequestHostInfraIPv4HostNetwork>;

export interface DirectoryServicesCreateRequestHostInfraIPv4Host {
  ipv4: string;
  network: DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
}
export const DirectoryServicesCreateRequestHostInfraIPv4Host =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      ipv4: S.String,
      network: DirectoryServicesCreateRequestHostInfraIPv4HostNetwork,
    }),
  ).annotate({
    identifier: "DirectoryServicesCreateRequestHostInfraIPv4Host",
  }) as any as S.Schema<DirectoryServicesCreateRequestHostInfraIPv4Host>;

export type DirectoryServicesCreateRequestHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesCreateRequestHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export interface DirectoryServicesCreateRequestHostInfraIPv6Host {
  ipv6: string;
  network: DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
}
export const DirectoryServicesCreateRequestHostInfraIPv6Host =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      ipv6: S.String,
      network: DirectoryServicesCreateRequestHostInfraIPv4HostNetwork,
    }),
  ).annotate({
    identifier: "DirectoryServicesCreateRequestHostInfraIPv6Host",
  }) as any as S.Schema<DirectoryServicesCreateRequestHostInfraIPv6Host>;

export type DirectoryServicesCreateRequestHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesCreateRequestHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export interface DirectoryServicesCreateRequestHostInfraDualStackHost {
  ipv4: string;
  ipv6: string;
  network: DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
}
export const DirectoryServicesCreateRequestHostInfraDualStackHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      ipv4: S.String,
      ipv6: S.String,
      network: DirectoryServicesCreateRequestHostInfraIPv4HostNetwork,
    }),
  ).annotate({
    identifier: "DirectoryServicesCreateRequestHostInfraDualStackHost",
  }) as any as S.Schema<DirectoryServicesCreateRequestHostInfraDualStackHost>;

export type DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetworkResolverIpsList =
  Array<string>;
export const DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetworkResolverIpsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetworkResolverIpsList>;

export interface DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetwork {
  tunnelId: string;
  resolverIps?: DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetworkResolverIpsList;
}
export const DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
      resolverIps: S.optional(
        DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetworkResolverIpsList.pipe(
          T.Body("resolver_ips"),
        ),
      ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetwork",
  }) as any as S.Schema<DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetwork>;

export interface DirectoryServicesCreateRequestHostInfraHostnameHost {
  hostname: string;
  resolverNetwork: DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetwork;
}
export const DirectoryServicesCreateRequestHostInfraHostnameHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      hostname: S.String,
      resolverNetwork:
        DirectoryServicesCreateRequestHostInfraHostnameHostResolverNetwork.pipe(
          T.Body("resolver_network"),
        ),
    }),
  ).annotate({
    identifier: "DirectoryServicesCreateRequestHostInfraHostnameHost",
  }) as any as S.Schema<DirectoryServicesCreateRequestHostInfraHostnameHost>;

export type DirectoryServicesCreateRequestHost =
  | DirectoryServicesCreateRequestHostInfraIPv4Host
  | DirectoryServicesCreateRequestHostInfraIPv6Host
  | DirectoryServicesCreateRequestHostInfraDualStackHost
  | DirectoryServicesCreateRequestHostInfraHostnameHost;
export const DirectoryServicesCreateRequestHost = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["ipv4", "network"],
    ["ipv6", "network"],
    ["ipv4", "ipv6", "network"],
    ["hostname", "resolverNetwork"],
  ]),
);

export type DirectoryServicesCreateRequestType = "tcp" | "http";
export const DirectoryServicesCreateRequestType = /*@__PURE__*/ S.String;

export interface DirectoryServicesCreateRequestTlsSettings {
  /** TLS certificate verification mode for the connection to the origin. */
  certVerificationMode: string;
}
export const DirectoryServicesCreateRequestTlsSettings =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      certVerificationMode: S.String.pipe(T.Body("cert_verification_mode")),
    }),
  ).annotate({
    identifier: "DirectoryServicesCreateRequestTlsSettings",
  }) as any as S.Schema<DirectoryServicesCreateRequestTlsSettings>;

export type DirectoryServicesCreateRequestAppProtocol = "postgresql" | "mysql";
export const DirectoryServicesCreateRequestAppProtocol = /*@__PURE__*/ S.String;

export interface CreateDirectoryServiceRequest {
  /** Account identifier */
  accountId: string;
  host: DirectoryServicesCreateRequestHost;
  name: string;
  type: DirectoryServicesCreateRequestType | (string & {});
  createdAt?: string;
  httpPort?: number;
  httpsPort?: number;
  serviceId?: string;
  /** TLS settings for a connectivity service. */
  tlsSettings?: DirectoryServicesCreateRequestTlsSettings;
  updatedAt?: string;
  appProtocol?: DirectoryServicesCreateRequestAppProtocol | (string & {});
  tcpPort?: number;
}
export const CreateDirectoryServiceRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    host: DirectoryServicesCreateRequestHost,
    name: S.String,
    type: DirectoryServicesCreateRequestType,
    createdAt: S.optional(S.String.pipe(T.Body("created_at"))),
    httpPort: S.optional(S.Number.pipe(T.Body("http_port"))),
    httpsPort: S.optional(S.Number.pipe(T.Body("https_port"))),
    serviceId: S.optional(S.String.pipe(T.Body("service_id"))),
    tlsSettings: S.optional(
      DirectoryServicesCreateRequestTlsSettings.pipe(T.Body("tls_settings")),
    ),
    updatedAt: S.optional(S.String.pipe(T.Body("updated_at"))),
    appProtocol: S.optional(
      DirectoryServicesCreateRequestAppProtocol.pipe(T.Body("app_protocol")),
    ),
    tcpPort: S.optional(S.Number.pipe(T.Body("tcp_port"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/connectivity/directory/services",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDirectoryServiceRequest",
}) as any as S.Schema<CreateDirectoryServiceRequest>;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  Array<string>;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList>;

export interface DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork {
  tunnelId: string;
  resolverIps?: DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList | null;
}
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
      resolverIps: S.optional(
        S.NullOr(
          DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList,
        ).pipe(T.Body("resolver_ips")),
      ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork",
  }) as any as S.Schema<DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork>;

export interface DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHost {
  hostname: string;
  resolverNetwork: DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork;
}
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      hostname: S.String,
      resolverNetwork:
        DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork.pipe(
          T.Body("resolver_network"),
        ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHost",
  }) as any as S.Schema<DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHost>;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigHost =
  | DirectoryServicesCreateRequestHostInfraIPv4Host
  | DirectoryServicesCreateRequestHostInfraIPv6Host
  | DirectoryServicesCreateRequestHostInfraDualStackHost
  | DirectoryServicesCreateResultInfraHTTPServiceConfigHostInfraHostnameHost;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigHost =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["ipv4", "network"],
      ["ipv6", "network"],
      ["ipv4", "ipv6", "network"],
      ["hostname", "resolverNetwork"],
    ]),
  );

export type DirectoryServicesCreateResultType = "tcp" | "http";
export const DirectoryServicesCreateResultType = /*@__PURE__*/ S.String;

export type DirectoryServicesCreateResultInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;
export const DirectoryServicesCreateResultInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;

export type DirectoryServicesCreateResultInfraTCPServiceConfigAppProtocol =
  | "postgresql"
  | "mysql";
export const DirectoryServicesCreateResultInfraTCPServiceConfigAppProtocol =
  /*@__PURE__*/ S.String;

export interface DirectoryServicesCreateResult {
  host: DirectoryServicesCreateResultInfraHTTPServiceConfigHost;
  name: string;
  type: DirectoryServicesCreateResultType;
  createdAt?: string | null;
  httpPort?: number | null;
  httpsPort?: number | null;
  serviceId?: string | null;
  /** TLS settings for a connectivity service. */
  tlsSettings?: DirectoryServicesCreateRequestTlsSettings | null;
  updatedAt?: string | null;
  appProtocol?: DirectoryServicesCreateResultInfraTCPServiceConfigAppProtocol | null;
  tcpPort?: number | null;
}
export const DirectoryServicesCreateResult = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    host: DirectoryServicesCreateResultInfraHTTPServiceConfigHost,
    name: S.String,
    type: DirectoryServicesCreateResultType,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    httpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("http_port"))),
    httpsPort: S.optional(S.NullOr(S.Number).pipe(T.Body("https_port"))),
    serviceId: S.optional(S.NullOr(S.String).pipe(T.Body("service_id"))),
    tlsSettings: S.optional(
      S.NullOr(DirectoryServicesCreateRequestTlsSettings).pipe(
        T.Body("tls_settings"),
      ),
    ),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    appProtocol: S.optional(
      S.NullOr(
        DirectoryServicesCreateResultInfraTCPServiceConfigAppProtocol,
      ).pipe(T.Body("app_protocol")),
    ),
    tcpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("tcp_port"))),
  }),
).annotate({
  identifier: "DirectoryServicesCreateResult",
}) as any as S.Schema<DirectoryServicesCreateResult>;

export type CreateDirectoryServiceResponse = DirectoryServicesCreateResult;
export const CreateDirectoryServiceResponse = /*@__PURE__*/ S.suspend(() =>
  DirectoryServicesCreateResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "CreateDirectoryServiceResponse",
}) as any as S.Schema<CreateDirectoryServiceResponse>;

export interface DeleteDirectoryServiceRequest {
  accountId: string;
  serviceId: string;
}
export const DeleteDirectoryServiceRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    serviceId: S.String.pipe(T.Label("service_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/connectivity/directory/services/{service_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDirectoryServiceRequest",
}) as any as S.Schema<DeleteDirectoryServiceRequest>;

export interface DeleteDirectoryServiceResponse {}
export const DeleteDirectoryServiceResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDirectoryServiceResponse",
}) as any as S.Schema<DeleteDirectoryServiceResponse>;

export interface GetDirectoryServiceRequest {
  accountId: string;
  serviceId: string;
}
export const GetDirectoryServiceRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    serviceId: S.String.pipe(T.Label("service_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/connectivity/directory/services/{service_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDirectoryServiceRequest",
}) as any as S.Schema<GetDirectoryServiceRequest>;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  Array<string>;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList>;

export interface DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork {
  tunnelId: string;
  resolverIps?: DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList | null;
}
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
      resolverIps: S.optional(
        S.NullOr(
          DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList,
        ).pipe(T.Body("resolver_ips")),
      ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork",
  }) as any as S.Schema<DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork>;

export interface DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHost {
  hostname: string;
  resolverNetwork: DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork;
}
export const DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      hostname: S.String,
      resolverNetwork:
        DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork.pipe(
          T.Body("resolver_network"),
        ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHost",
  }) as any as S.Schema<DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHost>;

export type DirectoryServicesGetResultInfraHTTPServiceConfigHost =
  | DirectoryServicesCreateRequestHostInfraIPv4Host
  | DirectoryServicesCreateRequestHostInfraIPv6Host
  | DirectoryServicesCreateRequestHostInfraDualStackHost
  | DirectoryServicesGetResultInfraHTTPServiceConfigHostInfraHostnameHost;
export const DirectoryServicesGetResultInfraHTTPServiceConfigHost =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["ipv4", "network"],
      ["ipv6", "network"],
      ["ipv4", "ipv6", "network"],
      ["hostname", "resolverNetwork"],
    ]),
  );

export type DirectoryServicesGetResultType = "tcp" | "http";
export const DirectoryServicesGetResultType = /*@__PURE__*/ S.String;

export type DirectoryServicesGetResultInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;
export const DirectoryServicesGetResultInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;

export type DirectoryServicesGetResultInfraTCPServiceConfigAppProtocol =
  | "postgresql"
  | "mysql";
export const DirectoryServicesGetResultInfraTCPServiceConfigAppProtocol =
  /*@__PURE__*/ S.String;

export interface DirectoryServicesGetResult {
  host: DirectoryServicesGetResultInfraHTTPServiceConfigHost;
  name: string;
  type: DirectoryServicesGetResultType;
  createdAt?: string | null;
  httpPort?: number | null;
  httpsPort?: number | null;
  serviceId?: string | null;
  /** TLS settings for a connectivity service. */
  tlsSettings?: DirectoryServicesCreateRequestTlsSettings | null;
  updatedAt?: string | null;
  appProtocol?: DirectoryServicesGetResultInfraTCPServiceConfigAppProtocol | null;
  tcpPort?: number | null;
}
export const DirectoryServicesGetResult = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    host: DirectoryServicesGetResultInfraHTTPServiceConfigHost,
    name: S.String,
    type: DirectoryServicesGetResultType,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    httpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("http_port"))),
    httpsPort: S.optional(S.NullOr(S.Number).pipe(T.Body("https_port"))),
    serviceId: S.optional(S.NullOr(S.String).pipe(T.Body("service_id"))),
    tlsSettings: S.optional(
      S.NullOr(DirectoryServicesCreateRequestTlsSettings).pipe(
        T.Body("tls_settings"),
      ),
    ),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    appProtocol: S.optional(
      S.NullOr(DirectoryServicesGetResultInfraTCPServiceConfigAppProtocol).pipe(
        T.Body("app_protocol"),
      ),
    ),
    tcpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("tcp_port"))),
  }),
).annotate({
  identifier: "DirectoryServicesGetResult",
}) as any as S.Schema<DirectoryServicesGetResult>;

export type GetDirectoryServiceResponse = DirectoryServicesGetResult;
export const GetDirectoryServiceResponse = /*@__PURE__*/ S.suspend(() =>
  DirectoryServicesGetResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "GetDirectoryServiceResponse",
}) as any as S.Schema<GetDirectoryServiceResponse>;

export type DirectoryServicesListRequestType = "tcp" | "http";
export const DirectoryServicesListRequestType = /*@__PURE__*/ S.String;

export interface ListDirectoryServicesRequest {
  /** Account identifier */
  accountId: string;
  /** Current page in the response */
  page?: number;
  /** Max amount of entries returned per page */
  perPage?: number;
  type?: DirectoryServicesListRequestType | (string & {});
}
export const ListDirectoryServicesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    type: S.optional(DirectoryServicesListRequestType.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/connectivity/directory/services",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDirectoryServicesRequest",
}) as any as S.Schema<ListDirectoryServicesRequest>;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  Array<string>;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList>;

export interface DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork {
  tunnelId: string;
  resolverIps?: DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList | null;
}
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
      resolverIps: S.optional(
        S.NullOr(
          DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList,
        ).pipe(T.Body("resolver_ips")),
      ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork",
  }) as any as S.Schema<DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork>;

export interface DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHost {
  hostname: string;
  resolverNetwork: DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork;
}
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      hostname: S.String,
      resolverNetwork:
        DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork.pipe(
          T.Body("resolver_network"),
        ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHost",
  }) as any as S.Schema<DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHost>;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigHost =
  | DirectoryServicesCreateRequestHostInfraIPv4Host
  | DirectoryServicesCreateRequestHostInfraIPv6Host
  | DirectoryServicesCreateRequestHostInfraDualStackHost
  | DirectoryServicesListResultItemInfraHTTPServiceConfigHostInfraHostnameHost;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigHost =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["ipv4", "network"],
      ["ipv6", "network"],
      ["ipv4", "ipv6", "network"],
      ["hostname", "resolverNetwork"],
    ]),
  );

export type DirectoryServicesListResultItemType = "tcp" | "http";
export const DirectoryServicesListResultItemType = /*@__PURE__*/ S.String;

export type DirectoryServicesListResultItemInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;
export const DirectoryServicesListResultItemInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;

export type DirectoryServicesListResultItemInfraTCPServiceConfigAppProtocol =
  | "postgresql"
  | "mysql";
export const DirectoryServicesListResultItemInfraTCPServiceConfigAppProtocol =
  /*@__PURE__*/ S.String;

export interface DirectoryServicesListResultItem {
  host: DirectoryServicesListResultItemInfraHTTPServiceConfigHost;
  name: string;
  type: DirectoryServicesListResultItemType;
  createdAt?: string | null;
  httpPort?: number | null;
  httpsPort?: number | null;
  serviceId?: string | null;
  /** TLS settings for a connectivity service. */
  tlsSettings?: DirectoryServicesCreateRequestTlsSettings | null;
  updatedAt?: string | null;
  appProtocol?: DirectoryServicesListResultItemInfraTCPServiceConfigAppProtocol | null;
  tcpPort?: number | null;
}
export const DirectoryServicesListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    host: DirectoryServicesListResultItemInfraHTTPServiceConfigHost,
    name: S.String,
    type: DirectoryServicesListResultItemType,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    httpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("http_port"))),
    httpsPort: S.optional(S.NullOr(S.Number).pipe(T.Body("https_port"))),
    serviceId: S.optional(S.NullOr(S.String).pipe(T.Body("service_id"))),
    tlsSettings: S.optional(
      S.NullOr(DirectoryServicesCreateRequestTlsSettings).pipe(
        T.Body("tls_settings"),
      ),
    ),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    appProtocol: S.optional(
      S.NullOr(
        DirectoryServicesListResultItemInfraTCPServiceConfigAppProtocol,
      ).pipe(T.Body("app_protocol")),
    ),
    tcpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("tcp_port"))),
  }),
).annotate({
  identifier: "DirectoryServicesListResultItem",
}) as any as S.Schema<DirectoryServicesListResultItem>;

export type DirectoryServicesListResultList =
  Array<DirectoryServicesListResultItem>;
export const DirectoryServicesListResultList = /*@__PURE__*/ S.Array(
  DirectoryServicesListResultItem,
) as any as S.Schema<DirectoryServicesListResultList>;

export interface ListDirectoryServicesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: DirectoryServicesListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListDirectoryServicesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: DirectoryServicesListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDirectoryServicesResponse",
}) as any as S.Schema<ListDirectoryServicesResponse>;

export type DirectoryServicesUpdateRequestHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesUpdateRequestHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesUpdateRequestHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;
export const DirectoryServicesUpdateRequestHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;

export type DirectoryServicesUpdateRequestHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesUpdateRequestHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesUpdateRequestHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;
export const DirectoryServicesUpdateRequestHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;

export type DirectoryServicesUpdateRequestHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesUpdateRequestHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesUpdateRequestHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;
export const DirectoryServicesUpdateRequestHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;

export type DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetworkResolverIpsList =
  Array<string>;
export const DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetworkResolverIpsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetworkResolverIpsList>;

export interface DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetwork {
  tunnelId: string;
  resolverIps?: DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetworkResolverIpsList;
}
export const DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
      resolverIps: S.optional(
        DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetworkResolverIpsList.pipe(
          T.Body("resolver_ips"),
        ),
      ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetwork",
  }) as any as S.Schema<DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetwork>;

export interface DirectoryServicesUpdateRequestHostInfraHostnameHost {
  hostname: string;
  resolverNetwork: DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetwork;
}
export const DirectoryServicesUpdateRequestHostInfraHostnameHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      hostname: S.String,
      resolverNetwork:
        DirectoryServicesUpdateRequestHostInfraHostnameHostResolverNetwork.pipe(
          T.Body("resolver_network"),
        ),
    }),
  ).annotate({
    identifier: "DirectoryServicesUpdateRequestHostInfraHostnameHost",
  }) as any as S.Schema<DirectoryServicesUpdateRequestHostInfraHostnameHost>;

export type DirectoryServicesUpdateRequestHost =
  | DirectoryServicesCreateRequestHostInfraIPv4Host
  | DirectoryServicesCreateRequestHostInfraIPv6Host
  | DirectoryServicesCreateRequestHostInfraDualStackHost
  | DirectoryServicesUpdateRequestHostInfraHostnameHost;
export const DirectoryServicesUpdateRequestHost = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["ipv4", "network"],
    ["ipv6", "network"],
    ["ipv4", "ipv6", "network"],
    ["hostname", "resolverNetwork"],
  ]),
);

export type DirectoryServicesUpdateRequestType = "tcp" | "http";
export const DirectoryServicesUpdateRequestType = /*@__PURE__*/ S.String;

export type DirectoryServicesUpdateRequestTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;
export const DirectoryServicesUpdateRequestTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;

export type DirectoryServicesUpdateRequestAppProtocol = "postgresql" | "mysql";
export const DirectoryServicesUpdateRequestAppProtocol = /*@__PURE__*/ S.String;

export interface UpdateDirectoryServiceRequest {
  accountId: string;
  serviceId: string;
  host: DirectoryServicesUpdateRequestHost;
  name: string;
  type: DirectoryServicesUpdateRequestType | (string & {});
  createdAt?: string;
  httpPort?: number;
  httpsPort?: number;
  /** TLS settings for a connectivity service. */
  tlsSettings?: DirectoryServicesCreateRequestTlsSettings;
  updatedAt?: string;
  appProtocol?: DirectoryServicesUpdateRequestAppProtocol | (string & {});
  tcpPort?: number;
}
export const UpdateDirectoryServiceRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    serviceId: S.String.pipe(T.Label("service_id")),
    host: DirectoryServicesUpdateRequestHost,
    name: S.String,
    type: DirectoryServicesUpdateRequestType,
    createdAt: S.optional(S.String.pipe(T.Body("created_at"))),
    httpPort: S.optional(S.Number.pipe(T.Body("http_port"))),
    httpsPort: S.optional(S.Number.pipe(T.Body("https_port"))),
    tlsSettings: S.optional(
      DirectoryServicesCreateRequestTlsSettings.pipe(T.Body("tls_settings")),
    ),
    updatedAt: S.optional(S.String.pipe(T.Body("updated_at"))),
    appProtocol: S.optional(
      DirectoryServicesUpdateRequestAppProtocol.pipe(T.Body("app_protocol")),
    ),
    tcpPort: S.optional(S.Number.pipe(T.Body("tcp_port"))),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/connectivity/directory/services/{service_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateDirectoryServiceRequest",
}) as any as S.Schema<UpdateDirectoryServiceRequest>;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv4HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv4Host =
  DirectoryServicesCreateRequestHostInfraIPv4Host;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv6HostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraIPv6Host =
  DirectoryServicesCreateRequestHostInfraIPv6Host;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraDualStackHostNetwork =
  DirectoryServicesCreateRequestHostInfraIPv4HostNetwork;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraDualStackHost =
  DirectoryServicesCreateRequestHostInfraDualStackHost;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  Array<string>;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList>;

export interface DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork {
  tunnelId: string;
  resolverIps?: DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList | null;
}
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      tunnelId: S.String.pipe(T.Body("tunnel_id")),
      resolverIps: S.optional(
        S.NullOr(
          DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetworkResolverIpsList,
        ).pipe(T.Body("resolver_ips")),
      ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork",
  }) as any as S.Schema<DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork>;

export interface DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHost {
  hostname: string;
  resolverNetwork: DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork;
}
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHost =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      hostname: S.String,
      resolverNetwork:
        DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHostResolverNetwork.pipe(
          T.Body("resolver_network"),
        ),
    }),
  ).annotate({
    identifier:
      "DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHost",
  }) as any as S.Schema<DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHost>;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigHost =
  | DirectoryServicesCreateRequestHostInfraIPv4Host
  | DirectoryServicesCreateRequestHostInfraIPv6Host
  | DirectoryServicesCreateRequestHostInfraDualStackHost
  | DirectoryServicesUpdateResultInfraHTTPServiceConfigHostInfraHostnameHost;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigHost =
  /*@__PURE__*/ S.Unknown.pipe(
    T.UnionCases([
      ["ipv4", "network"],
      ["ipv6", "network"],
      ["ipv4", "ipv6", "network"],
      ["hostname", "resolverNetwork"],
    ]),
  );

export type DirectoryServicesUpdateResultType = "tcp" | "http";
export const DirectoryServicesUpdateResultType = /*@__PURE__*/ S.String;

export type DirectoryServicesUpdateResultInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;
export const DirectoryServicesUpdateResultInfraHTTPServiceConfigTlsSettings =
  DirectoryServicesCreateRequestTlsSettings;

export type DirectoryServicesUpdateResultInfraTCPServiceConfigAppProtocol =
  | "postgresql"
  | "mysql";
export const DirectoryServicesUpdateResultInfraTCPServiceConfigAppProtocol =
  /*@__PURE__*/ S.String;

export interface DirectoryServicesUpdateResult {
  host: DirectoryServicesUpdateResultInfraHTTPServiceConfigHost;
  name: string;
  type: DirectoryServicesUpdateResultType;
  createdAt?: string | null;
  httpPort?: number | null;
  httpsPort?: number | null;
  serviceId?: string | null;
  /** TLS settings for a connectivity service. */
  tlsSettings?: DirectoryServicesCreateRequestTlsSettings | null;
  updatedAt?: string | null;
  appProtocol?: DirectoryServicesUpdateResultInfraTCPServiceConfigAppProtocol | null;
  tcpPort?: number | null;
}
export const DirectoryServicesUpdateResult = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    host: DirectoryServicesUpdateResultInfraHTTPServiceConfigHost,
    name: S.String,
    type: DirectoryServicesUpdateResultType,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    httpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("http_port"))),
    httpsPort: S.optional(S.NullOr(S.Number).pipe(T.Body("https_port"))),
    serviceId: S.optional(S.NullOr(S.String).pipe(T.Body("service_id"))),
    tlsSettings: S.optional(
      S.NullOr(DirectoryServicesCreateRequestTlsSettings).pipe(
        T.Body("tls_settings"),
      ),
    ),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
    appProtocol: S.optional(
      S.NullOr(
        DirectoryServicesUpdateResultInfraTCPServiceConfigAppProtocol,
      ).pipe(T.Body("app_protocol")),
    ),
    tcpPort: S.optional(S.NullOr(S.Number).pipe(T.Body("tcp_port"))),
  }),
).annotate({
  identifier: "DirectoryServicesUpdateResult",
}) as any as S.Schema<DirectoryServicesUpdateResult>;

export type UpdateDirectoryServiceResponse = DirectoryServicesUpdateResult;
export const UpdateDirectoryServiceResponse = /*@__PURE__*/ S.suspend(() =>
  DirectoryServicesUpdateResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "UpdateDirectoryServiceResponse",
}) as any as S.Schema<UpdateDirectoryServiceResponse>;

export type CreateDirectoryServiceError =
  | VpcServiceNameAlreadyExists
  | VpcTunnelNotFound
  | Forbidden
  | CloudflareOpError;
/** Create Workers VPC connectivity service */
export const createDirectoryService: API.OperationMethod<
  CreateDirectoryServiceRequest,
  CreateDirectoryServiceResponse,
  CreateDirectoryServiceError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateDirectoryServiceRequest,
  output: CreateDirectoryServiceResponse,
  errors: [
    VpcServiceNameAlreadyExists,
    VpcTunnelNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteDirectoryServiceError =
  | VpcServiceNotFound
  | Forbidden
  | CloudflareOpError;
/** Delete Workers VPC connectivity service */
export const deleteDirectoryService: API.OperationMethod<
  DeleteDirectoryServiceRequest,
  DeleteDirectoryServiceResponse,
  DeleteDirectoryServiceError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteDirectoryServiceRequest,
  output: DeleteDirectoryServiceResponse,
  errors: [
    VpcServiceNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDirectoryServiceError =
  | VpcServiceNotFound
  | Forbidden
  | CloudflareOpError;
/** Get Workers VPC connectivity service */
export const getDirectoryService: API.OperationMethod<
  GetDirectoryServiceRequest,
  GetDirectoryServiceResponse,
  GetDirectoryServiceError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDirectoryServiceRequest,
  output: GetDirectoryServiceResponse,
  errors: [
    VpcServiceNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListDirectoryServicesError = Forbidden | CloudflareOpError;
/** List Workers VPC connectivity services */
export const listDirectoryServices: API.PaginatedOperationMethod<
  ListDirectoryServicesRequest,
  ListDirectoryServicesResponse,
  ListDirectoryServicesError,
  CloudflareOpContext,
  DirectoryServicesListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListDirectoryServicesRequest,
    output: ListDirectoryServicesResponse,
    errors: [Forbidden, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type UpdateDirectoryServiceError =
  | VpcServiceNotFound
  | VpcServiceNameAlreadyExists
  | VpcTunnelNotFound
  | Forbidden
  | CloudflareOpError;
/** Update Workers VPC connectivity service */
export const updateDirectoryService: API.OperationMethod<
  UpdateDirectoryServiceRequest,
  UpdateDirectoryServiceResponse,
  UpdateDirectoryServiceError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateDirectoryServiceRequest,
  output: UpdateDirectoryServiceResponse,
  errors: [
    VpcServiceNotFound,
    VpcServiceNameAlreadyExists,
    VpcTunnelNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));