@distilled.cloud/ovh 0.0.0 → 1.0.0-rc.9

package/src/services/ip.ts

@@ -0,0 +1,4462 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-ovh). 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 {
+  OvhProtocol,
+  type OvhOpError,
+  type OvhOpContext,
+} from "../protocol.ts";
+import { UnknownOvhError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { OvhOpError, OvhOpContext };
+
+/** All future uses you can provide for a service termination */
+export type ServiceTerminationFutureUseEnum =
+  | "NOT_REPLACING_SERVICE"
+  | "OTHER"
+  | "SUBSCRIBE_AN_OTHER_SERVICE"
+  | "SUBSCRIBE_OTHER_KIND_OF_SERVICE_WITH_COMPETITOR"
+  | "SUBSCRIBE_SIMILAR_SERVICE_WITH_COMPETITOR";
+export const ServiceTerminationFutureUseEnum = /*@__PURE__*/ S.String;
+
+/** All reasons you can provide for a service termination */
+export type ServiceTerminationReasonEnum =
+  | "FEATURES_DONT_SUIT_ME"
+  | "LACK_OF_PERFORMANCES"
+  | "MIGRATED_TO_ANOTHER_OVH_PRODUCT"
+  | "MIGRATED_TO_COMPETITOR"
+  | "NOT_ENOUGH_RECOGNITION"
+  | "NOT_NEEDED_ANYMORE"
+  | "NOT_RELIABLE"
+  | "NO_ANSWER"
+  | "OTHER"
+  | "PRODUCT_DIMENSION_DONT_SUIT_ME"
+  | "PRODUCT_TOOLS_DONT_SUIT_ME"
+  | "TOO_EXPENSIVE"
+  | "TOO_HARD_TO_USE"
+  | "UNSATIFIED_BY_CUSTOMER_SUPPORT";
+export const ServiceTerminationReasonEnum = /*@__PURE__*/ S.String;
+
+export interface ConfirmIpServiceTerminationRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+  /** Commentary about your termination request */
+  commentary?: string;
+  /** What next after your termination request */
+  futureUse?: ServiceTerminationFutureUseEnum | (string & {});
+  /** Reason of your termination request */
+  reason?: ServiceTerminationReasonEnum | (string & {});
+  /** The termination token sent by email to the admin contact */
+  token: string;
+}
+export const ConfirmIpServiceTerminationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    commentary: S.optional(S.String),
+    futureUse: S.optional(ServiceTerminationFutureUseEnum),
+    reason: S.optional(ServiceTerminationReasonEnum),
+    token: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/service/{serviceName}/confirmTermination",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ConfirmIpServiceTerminationRequest",
+}) as any as S.Schema<ConfirmIpServiceTerminationRequest>;
+
+export type ConfirmIpServiceTerminationResponse = string;
+export const ConfirmIpServiceTerminationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ConfirmIpServiceTerminationResponse",
+}) as any as S.Schema<ConfirmIpServiceTerminationResponse>;
+
+export interface CreateIpBringYourOwnIpAggregateRequest {
+  ip: string;
+  /** IP range to create by aggregation of all it's children */
+  aggregationIp: string;
+}
+export const CreateIpBringYourOwnIpAggregateRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      ip: S.String.pipe(T.Label()),
+      aggregationIp: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/ip/{ip}/bringYourOwnIp/aggregate",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateIpBringYourOwnIpAggregateRequest",
+}) as any as S.Schema<CreateIpBringYourOwnIpAggregateRequest>;
+
+/** Information about routing */
+export interface IpRoutedTo {
+  /** Service where ip is routed to */
+  serviceName?: string | null;
+}
+export const IpRoutedTo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "IpRoutedTo" }) as any as S.Schema<IpRoutedTo>;
+
+/** different task operation */
+export type IpTaskFunctionEnum =
+  | "arinBlockReassign"
+  | "changeRipeOrg"
+  | "checkAndReleaseIp"
+  | "genericMoveFloatingIp"
+  | "supernetByoipFailoverPartitioning";
+export const IpTaskFunctionEnum = /*@__PURE__*/ S.String;
+
+/** different task status */
+export type IpTaskStatusEnum =
+  | "cancelled"
+  | "customerError"
+  | "doing"
+  | "done"
+  | "init"
+  | "ovhError"
+  | "todo";
+export const IpTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** IP tasks */
+export interface IpIpTask {
+  /** Details of this task */
+  comment?: string | null;
+  /** Destination for moveFloatingIp tasks */
+  destination?: IpRoutedTo | null;
+  /** Completion date */
+  doneDate?: string | null;
+  /** Function name */
+  function?: IpTaskFunctionEnum;
+  /** last update */
+  lastUpdate?: string | null;
+  /** Task Creation date */
+  startDate?: string;
+  /** Task status */
+  status?: IpTaskStatusEnum;
+  /** the id of the task */
+  taskId?: number;
+}
+export const IpIpTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.NullOr(S.String)),
+    destination: S.optional(S.NullOr(IpRoutedTo)),
+    doneDate: S.optional(S.NullOr(S.String)),
+    function: S.optional(IpTaskFunctionEnum),
+    lastUpdate: S.optional(S.NullOr(S.String)),
+    startDate: S.optional(S.String),
+    status: S.optional(IpTaskStatusEnum),
+    taskId: S.optional(S.Number),
+  }),
+).annotate({ identifier: "IpIpTask" }) as any as S.Schema<IpIpTask>;
+
+export interface CreateIpBringYourOwnIpSliceRequest {
+  ip: string;
+  /** Size (ip mask) of the IPs to create inside given IP */
+  slicingSize: number;
+}
+export const CreateIpBringYourOwnIpSliceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    slicingSize: S.Number,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/ip/{ip}/bringYourOwnIp/slice", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateIpBringYourOwnIpSliceRequest",
+}) as any as S.Schema<CreateIpBringYourOwnIpSliceRequest>;
+
+export interface CreateIpChangeOrgRequest {
+  ip: string;
+  /** Your organisation id (RIPE_XXXX) to add on block informations */
+  organisation: string;
+}
+export const CreateIpChangeOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    organisation: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/changeOrg", code: 200 })),
+).annotate({
+  identifier: "CreateIpChangeOrgRequest",
+}) as any as S.Schema<CreateIpChangeOrgRequest>;
+
+export interface CreateIpDelegationRequest {
+  ip: string;
+  /** Target for reverse delegation on IPv6 */
+  target: string;
+}
+export const CreateIpDelegationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    target: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/delegation", code: 200 })),
+).annotate({
+  identifier: "CreateIpDelegationRequest",
+}) as any as S.Schema<CreateIpDelegationRequest>;
+
+/** Your reverse delegations on IPv6 subnet */
+export interface IpReverseDelegation {
+  /** NS target for delegation */
+  target?: string;
+}
+export const IpReverseDelegation = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    target: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "IpReverseDelegation",
+}) as any as S.Schema<IpReverseDelegation>;
+
+export interface CreateIpFirewallRequest {
+  ip: string;
+  ipOnFirewall: string;
+}
+export const CreateIpFirewallRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/firewall", code: 200 })),
+).annotate({
+  identifier: "CreateIpFirewallRequest",
+}) as any as S.Schema<CreateIpFirewallRequest>;
+
+/** Possible values for firewall ip state */
+export type IpFirewallStateEnum =
+  | "disableFirewallPending"
+  | "enableFirewallPending"
+  | "ok";
+export const IpFirewallStateEnum = /*@__PURE__*/ S.String;
+
+/** Your IP on firewall */
+export interface IpFirewallIp {
+  enabled?: boolean;
+  ipOnFirewall?: string;
+  /** Current state of your ip on firewall */
+  state?: IpFirewallStateEnum;
+}
+export const IpFirewallIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.optional(S.Boolean),
+    ipOnFirewall: S.optional(S.String),
+    state: S.optional(IpFirewallStateEnum),
+  }),
+).annotate({ identifier: "IpFirewallIp" }) as any as S.Schema<IpFirewallIp>;
+
+/** Possible values for action */
+export type IpFirewallActionEnum = "deny" | "permit";
+export const IpFirewallActionEnum = /*@__PURE__*/ S.String;
+
+/** Possible values for protocol */
+export type IpFirewallProtocolEnum =
+  | "ah"
+  | "esp"
+  | "gre"
+  | "icmp"
+  | "ipv4"
+  | "tcp"
+  | "udp";
+export const IpFirewallProtocolEnum = /*@__PURE__*/ S.String;
+
+/** Possible values for action */
+export type IpFirewallSequenceRangeEnum =
+  | 0
+  | 1
+  | 2
+  | 3
+  | 4
+  | 5
+  | 6
+  | 7
+  | 8
+  | 9
+  | 10
+  | 11
+  | 12
+  | 13
+  | 14
+  | 15
+  | 16
+  | 17
+  | 18
+  | 19;
+export const IpFirewallSequenceRangeEnum = /*@__PURE__*/ S.Number;
+
+/** Possible values for TCP option - only for TCP protocol */
+export type IpFirewallTCPOptionEnum = "established" | "syn";
+export const IpFirewallTCPOptionEnum = /*@__PURE__*/ S.String;
+
+/** Possible option for TCP */
+export interface IpFirewallOptionTCP {
+  /** TCP fragments */
+  fragments?: boolean | null;
+  /** TCP option */
+  option?: IpFirewallTCPOptionEnum | (string & {}) | null;
+}
+export const IpFirewallOptionTCP = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    fragments: S.optional(S.NullOr(S.Boolean)),
+    option: S.optional(S.NullOr(IpFirewallTCPOptionEnum)),
+  }),
+).annotate({
+  identifier: "IpFirewallOptionTCP",
+}) as any as S.Schema<IpFirewallOptionTCP>;
+
+export interface CreateIpFirewallRuleRequest {
+  ip: string;
+  ipOnFirewall: string;
+  /** Action on this rule */
+  action: IpFirewallActionEnum | (string & {});
+  /** Destination port for your rule. Only with TCP/UDP protocol */
+  destinationPort?: number;
+  /** Network protocol */
+  protocol: IpFirewallProtocolEnum | (string & {});
+  /** Sequence number of your rule */
+  sequence: IpFirewallSequenceRangeEnum | (number & {});
+  /** Source ip for your rule. Any if not set */
+  source?: string;
+  /** Source port for your rule. Only with TCP/UDP protocol */
+  sourcePort?: number;
+  /** Option on your rule. Can only be used with TCP protocol */
+  tcpOption?: IpFirewallOptionTCP;
+}
+export const CreateIpFirewallRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+    action: IpFirewallActionEnum,
+    destinationPort: S.optional(S.Number),
+    protocol: IpFirewallProtocolEnum,
+    sequence: IpFirewallSequenceRangeEnum,
+    source: S.optional(S.String),
+    sourcePort: S.optional(S.Number),
+    tcpOption: S.optional(IpFirewallOptionTCP),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}/rule",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateIpFirewallRuleRequest",
+}) as any as S.Schema<CreateIpFirewallRuleRequest>;
+
+/** Possible values for firewall rule state */
+export type IpFirewallRuleStateEnum =
+  | "creationPending"
+  | "ok"
+  | "removalPending";
+export const IpFirewallRuleStateEnum = /*@__PURE__*/ S.String;
+
+/** Rule on ip */
+export interface IpFirewallNetworkRule {
+  /** Action on this rule */
+  action?: IpFirewallActionEnum;
+  creationDate?: string;
+  /** Destination ip for your rule */
+  destination?: string;
+  /** Destination port range for your rule. Only with TCP/UDP protocol */
+  destinationPort?: string | null;
+  /** Fragments option */
+  fragments?: boolean | null;
+  /** Network protocol */
+  protocol?: IpFirewallProtocolEnum;
+  rule?: string;
+  sequence?: number;
+  /** Source ip for your rule */
+  source?: string;
+  /** Source port range for your rule. Only with TCP/UDP protocol */
+  sourcePort?: string | null;
+  /** Current state of your rule */
+  state?: IpFirewallRuleStateEnum;
+  /** TCP option on your rule */
+  tcpOption?: string | null;
+}
+export const IpFirewallNetworkRule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    action: S.optional(IpFirewallActionEnum),
+    creationDate: S.optional(S.String),
+    destination: S.optional(S.String),
+    destinationPort: S.optional(S.NullOr(S.String)),
+    fragments: S.optional(S.NullOr(S.Boolean)),
+    protocol: S.optional(IpFirewallProtocolEnum),
+    rule: S.optional(S.String),
+    sequence: S.optional(S.Number),
+    source: S.optional(S.String),
+    sourcePort: S.optional(S.NullOr(S.String)),
+    state: S.optional(IpFirewallRuleStateEnum),
+    tcpOption: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "IpFirewallNetworkRule",
+}) as any as S.Schema<IpFirewallNetworkRule>;
+
+/** Start and end points (inclusive) of a range */
+export interface ComplexTypeRangeLong {
+  from?: number;
+  to?: number;
+}
+export const ComplexTypeRangeLong = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    from: S.optional(S.Number),
+    to: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ComplexTypeRangeLong",
+}) as any as S.Schema<ComplexTypeRangeLong>;
+
+/** Possible values for game rule protocol */
+export type IpGameMitigationRuleProtocolEnum =
+  | "arkSurvivalEvolved"
+  | "arkSurvivalEvolvedV311.78+"
+  | "arma"
+  | "counterStrike2"
+  | "fiveM"
+  | "gtaMultiTheftAutoSanAndreas"
+  | "gtaSanAndreasMultiplayerMod"
+  | "hl2Source"
+  | "minecraftBedrockWithRacknetCookie"
+  | "minecraftJava"
+  | "minecraftPocketEdition"
+  | "minecraftQuery"
+  | "mumble"
+  | "other"
+  | "rust"
+  | "teamspeak2"
+  | "teamspeak3"
+  | "trackmaniaShootmania"
+  | "valheim";
+export const IpGameMitigationRuleProtocolEnum = /*@__PURE__*/ S.String;
+
+export interface CreateIpGameRuleRequest {
+  ip: string;
+  ipOnGame: string;
+  /** The UDP port range to apply the rule on */
+  ports: ComplexTypeRangeLong;
+  /** The protocol running behind the given port(s). See supportedProtocols on the IP to know which values are valid here */
+  protocol: IpGameMitigationRuleProtocolEnum | (string & {});
+}
+export const CreateIpGameRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnGame: S.String.pipe(T.Label()),
+    ports: ComplexTypeRangeLong,
+    protocol: IpGameMitigationRuleProtocolEnum,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/ip/{ip}/game/{ipOnGame}/rule", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateIpGameRuleRequest",
+}) as any as S.Schema<CreateIpGameRuleRequest>;
+
+/** Possible values for game mitigation rule state */
+export type IpGameMitigationRuleStateEnum =
+  | "createRulePending"
+  | "deleteRulePending"
+  | "ok";
+export const IpGameMitigationRuleStateEnum = /*@__PURE__*/ S.String;
+
+/** Rule on ip:ports */
+export interface IpGameMitigationRule {
+  /** ID of the rule */
+  id?: number;
+  ports?: ComplexTypeRangeLong;
+  protocol?: IpGameMitigationRuleProtocolEnum;
+  /** Current state of your rule */
+  state?: IpGameMitigationRuleStateEnum;
+}
+export const IpGameMitigationRule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.Number),
+    ports: S.optional(ComplexTypeRangeLong),
+    protocol: S.optional(IpGameMitigationRuleProtocolEnum),
+    state: S.optional(IpGameMitigationRuleStateEnum),
+  }),
+).annotate({
+  identifier: "IpGameMitigationRule",
+}) as any as S.Schema<IpGameMitigationRule>;
+
+export interface CreateIpMigrationTokenRequest {
+  ip: string;
+  /** destination customer ID */
+  customerId: string;
+}
+export const CreateIpMigrationTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    customerId: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/ip/{ip}/migrationToken", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateIpMigrationTokenRequest",
+}) as any as S.Schema<CreateIpMigrationTokenRequest>;
+
+/** IP migration to OVH */
+export interface IpIpMigrationToken {
+  /** destination customer ID */
+  customerId?: string;
+  /** migration token */
+  token?: string;
+}
+export const IpIpMigrationToken = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    customerId: S.optional(S.String),
+    token: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "IpIpMigrationToken",
+}) as any as S.Schema<IpIpMigrationToken>;
+
+export interface CreateIpMitigationRequest {
+  ip: string;
+  ipOnMitigation: string;
+}
+export const CreateIpMitigationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnMitigation: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/mitigation", code: 200 })),
+).annotate({
+  identifier: "CreateIpMitigationRequest",
+}) as any as S.Schema<CreateIpMitigationRequest>;
+
+/** Possible values for mitigation state */
+export type IpMitigationStateEnum = "creationPending" | "ok" | "removalPending";
+export const IpMitigationStateEnum = /*@__PURE__*/ S.String;
+
+/** Your IP on mitigation */
+export interface IpMitigationIp {
+  /** Set on true if your ip is on auto-mitigation */
+  auto?: boolean;
+  ipOnMitigation?: string;
+  /** Set on true if your ip is on permanent mitigation */
+  permanent?: boolean;
+  /** Current state of your ip on mitigation */
+  state?: IpMitigationStateEnum;
+}
+export const IpMitigationIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    auto: S.optional(S.Boolean),
+    ipOnMitigation: S.optional(S.String),
+    permanent: S.optional(S.Boolean),
+    state: S.optional(IpMitigationStateEnum),
+  }),
+).annotate({ identifier: "IpMitigationIp" }) as any as S.Schema<IpMitigationIp>;
+
+/** Possible values for auto mitigation timeout (minutes) */
+export type IpMitigationProfileAutoMitigationTimeOutEnum =
+  | 0
+  | 15
+  | 60
+  | 360
+  | 1560;
+export const IpMitigationProfileAutoMitigationTimeOutEnum =
+  /*@__PURE__*/ S.Number;
+
+export interface CreateIpMitigationProfileRequest {
+  ip: string;
+  /** Delay to wait before remove ip from auto mitigation after an attack */
+  autoMitigationTimeOut:
+    | IpMitigationProfileAutoMitigationTimeOutEnum
+    | (number & {});
+  ipMitigationProfile: string;
+}
+export const CreateIpMitigationProfileRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    autoMitigationTimeOut: IpMitigationProfileAutoMitigationTimeOutEnum,
+    ipMitigationProfile: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/ip/{ip}/mitigationProfiles", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateIpMitigationProfileRequest",
+}) as any as S.Schema<CreateIpMitigationProfileRequest>;
+
+/** Possible values for mitigation profile state */
+export type IpMitigationProfileStateEnum = "ok" | "tasksPending";
+export const IpMitigationProfileStateEnum = /*@__PURE__*/ S.String;
+
+/** Mitigation profile for your ip */
+export interface IpMitigationProfile {
+  /** Delay to wait before remove ip from auto mitigation after an attack */
+  autoMitigationTimeOut?: IpMitigationProfileAutoMitigationTimeOutEnum;
+  ipMitigationProfile?: string;
+  /** Current state of your mitigation profile */
+  state?: IpMitigationProfileStateEnum;
+}
+export const IpMitigationProfile = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    autoMitigationTimeOut: S.optional(
+      IpMitigationProfileAutoMitigationTimeOutEnum,
+    ),
+    ipMitigationProfile: S.optional(S.String),
+    state: S.optional(IpMitigationProfileStateEnum),
+  }),
+).annotate({
+  identifier: "IpMitigationProfile",
+}) as any as S.Schema<IpMitigationProfile>;
+
+export interface CreateIpParkRequest {
+  ip: string;
+}
+export const CreateIpParkRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/park", code: 200 })),
+).annotate({
+  identifier: "CreateIpParkRequest",
+}) as any as S.Schema<CreateIpParkRequest>;
+
+export interface CreateIpReverseRequest {
+  ip: string;
+  ipReverse: string;
+  reverse: string;
+}
+export const CreateIpReverseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipReverse: S.String,
+    reverse: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/reverse", code: 200 })),
+).annotate({
+  identifier: "CreateIpReverseRequest",
+}) as any as S.Schema<CreateIpReverseRequest>;
+
+/** Your reverse records on IP */
+export interface IpReverseIp {
+  ipReverse?: string;
+  reverse?: string;
+}
+export const IpReverseIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ipReverse: S.optional(S.String),
+    reverse: S.optional(S.String),
+  }),
+).annotate({ identifier: "IpReverseIp" }) as any as S.Schema<IpReverseIp>;
+
+export interface CreateIpServiceChangeContactRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+  /** The contact to set as admin contact */
+  contactAdmin?: string;
+  /** The contact to set as billing contact */
+  contactBilling?: string;
+  /** The contact to set as tech contact */
+  contactTech?: string;
+}
+export const CreateIpServiceChangeContactRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    contactAdmin: S.optional(S.String),
+    contactBilling: S.optional(S.String),
+    contactTech: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/service/{serviceName}/changeContact",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateIpServiceChangeContactRequest",
+}) as any as S.Schema<CreateIpServiceChangeContactRequest>;
+
+export type CreateIpServiceChangeContactResponseBodyList = Array<number>;
+export const CreateIpServiceChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateIpServiceChangeContactResponseBodyList>;
+
+export type CreateIpServiceChangeContactResponse =
+  CreateIpServiceChangeContactResponseBodyList;
+export const CreateIpServiceChangeContactResponse = /*@__PURE__*/ S.suspend(
+  () => CreateIpServiceChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateIpServiceChangeContactResponse",
+}) as any as S.Schema<CreateIpServiceChangeContactResponse>;
+
+export interface DeleteIpDelegationRequest {
+  ip: string;
+  /** NS target for delegation */
+  target: string;
+}
+export const DeleteIpDelegationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    target: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/delegation/{target}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpDelegationRequest",
+}) as any as S.Schema<DeleteIpDelegationRequest>;
+
+export interface DeleteIpDelegationResponse {}
+export const DeleteIpDelegationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteIpDelegationResponse",
+}) as any as S.Schema<DeleteIpDelegationResponse>;
+
+export interface DeleteIpFirewallRequest {
+  ip: string;
+  ipOnFirewall: string;
+}
+export const DeleteIpFirewallRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpFirewallRequest",
+}) as any as S.Schema<DeleteIpFirewallRequest>;
+
+export type DeleteIpFirewallResponse = string;
+export const DeleteIpFirewallResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteIpFirewallResponse",
+}) as any as S.Schema<DeleteIpFirewallResponse>;
+
+export interface DeleteIpFirewallRuleRequest {
+  ip: string;
+  ipOnFirewall: string;
+  sequence: number;
+}
+export const DeleteIpFirewallRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+    sequence: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}/rule/{sequence}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpFirewallRuleRequest",
+}) as any as S.Schema<DeleteIpFirewallRuleRequest>;
+
+export interface DeleteIpGameRuleRequest {
+  ip: string;
+  ipOnGame: string;
+  /** ID of the rule */
+  id: number;
+}
+export const DeleteIpGameRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnGame: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/game/{ipOnGame}/rule/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpGameRuleRequest",
+}) as any as S.Schema<DeleteIpGameRuleRequest>;
+
+export interface DeleteIpMitigationRequest {
+  ip: string;
+  ipOnMitigation: string;
+}
+export const DeleteIpMitigationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnMitigation: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/mitigation/{ipOnMitigation}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpMitigationRequest",
+}) as any as S.Schema<DeleteIpMitigationRequest>;
+
+export interface DeleteIpMitigationProfileRequest {
+  ip: string;
+  ipMitigationProfile: string;
+}
+export const DeleteIpMitigationProfileRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipMitigationProfile: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/mitigationProfiles/{ipMitigationProfile}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpMitigationProfileRequest",
+}) as any as S.Schema<DeleteIpMitigationProfileRequest>;
+
+export interface DeleteIpMitigationProfileResponse {}
+export const DeleteIpMitigationProfileResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteIpMitigationProfileResponse",
+}) as any as S.Schema<DeleteIpMitigationProfileResponse>;
+
+export interface DeleteIpReverseRequest {
+  ip: string;
+  ipReverse: string;
+}
+export const DeleteIpReverseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipReverse: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/ip/{ip}/reverse/{ipReverse}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIpReverseRequest",
+}) as any as S.Schema<DeleteIpReverseRequest>;
+
+export interface DeleteIpReverseResponse {}
+export const DeleteIpReverseResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteIpReverseResponse",
+}) as any as S.Schema<DeleteIpReverseResponse>;
+
+export interface GetIpRequest {
+  ip: string;
+}
+export const GetIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}", code: 200 })),
+).annotate({ identifier: "GetIpRequest" }) as any as S.Schema<GetIpRequest>;
+
+/** ISO country codes */
+export type CoreTypesCountryEnum =
+  | "ac"
+  | "ad"
+  | "ae"
+  | "af"
+  | "ag"
+  | "ai"
+  | "al"
+  | "am"
+  | "an"
+  | "ao"
+  | "aq"
+  | "ar"
+  | "as"
+  | "at"
+  | "au"
+  | "aw"
+  | "ax"
+  | "az"
+  | "ba"
+  | "bb"
+  | "bd"
+  | "be"
+  | "bf"
+  | "bg"
+  | "bh"
+  | "bi"
+  | "bj"
+  | "bl"
+  | "bm"
+  | "bn"
+  | "bo"
+  | "bq"
+  | "br"
+  | "bs"
+  | "bt"
+  | "bv"
+  | "bw"
+  | "by"
+  | "bz"
+  | "ca"
+  | "cc"
+  | "cd"
+  | "cf"
+  | "cg"
+  | "ch"
+  | "ci"
+  | "ck"
+  | "cl"
+  | "cm"
+  | "cn"
+  | "co"
+  | "cr"
+  | "cs"
+  | "cu"
+  | "cv"
+  | "cw"
+  | "cx"
+  | "cy"
+  | "cz"
+  | "de"
+  | "dj"
+  | "dk"
+  | "dm"
+  | "do"
+  | "dz"
+  | "ec"
+  | "ee"
+  | "eg"
+  | "eh"
+  | "er"
+  | "es"
+  | "et"
+  | "fc"
+  | "fd"
+  | "fi"
+  | "fj"
+  | "fk"
+  | "fm"
+  | "fo"
+  | "fr"
+  | "fx"
+  | "ga"
+  | "gb"
+  | "gd"
+  | "ge"
+  | "gf"
+  | "gg"
+  | "gh"
+  | "gi"
+  | "gl"
+  | "gm"
+  | "gn"
+  | "gp"
+  | "gq"
+  | "gr"
+  | "gs"
+  | "gt"
+  | "gu"
+  | "gw"
+  | "gy"
+  | "hk"
+  | "hm"
+  | "hn"
+  | "hr"
+  | "ht"
+  | "hu"
+  | "id"
+  | "ie"
+  | "il"
+  | "im"
+  | "in"
+  | "io"
+  | "iq"
+  | "ir"
+  | "is"
+  | "it"
+  | "je"
+  | "jm"
+  | "jo"
+  | "jp"
+  | "ke"
+  | "kg"
+  | "kh"
+  | "ki"
+  | "km"
+  | "kn"
+  | "kp"
+  | "kr"
+  | "kw"
+  | "ky"
+  | "kz"
+  | "la"
+  | "lb"
+  | "lc"
+  | "li"
+  | "lk"
+  | "lr"
+  | "ls"
+  | "lt"
+  | "lu"
+  | "lv"
+  | "ly"
+  | "ma"
+  | "mc"
+  | "md"
+  | "me"
+  | "mf"
+  | "mg"
+  | "mh"
+  | "mk"
+  | "ml"
+  | "mm"
+  | "mn"
+  | "mo"
+  | "mp"
+  | "mq"
+  | "mr"
+  | "ms"
+  | "mt"
+  | "mu"
+  | "mv"
+  | "mw"
+  | "mx"
+  | "my"
+  | "mz"
+  | "na"
+  | "nc"
+  | "ne"
+  | "nf"
+  | "ng"
+  | "ni"
+  | "nl"
+  | "no"
+  | "np"
+  | "nr"
+  | "nu"
+  | "nz"
+  | "om"
+  | "pa"
+  | "pe"
+  | "pf"
+  | "pg"
+  | "ph"
+  | "pk"
+  | "pl"
+  | "pm"
+  | "pn"
+  | "pr"
+  | "ps"
+  | "pt"
+  | "pw"
+  | "py"
+  | "qa"
+  | "qc"
+  | "re"
+  | "ro"
+  | "rs"
+  | "ru"
+  | "rw"
+  | "sa"
+  | "sb"
+  | "sc"
+  | "sd"
+  | "se"
+  | "sg"
+  | "sh"
+  | "si"
+  | "sj"
+  | "sk"
+  | "sl"
+  | "sm"
+  | "sn"
+  | "so"
+  | "sr"
+  | "ss"
+  | "st"
+  | "sv"
+  | "sx"
+  | "sy"
+  | "sz"
+  | "tc"
+  | "td"
+  | "tf"
+  | "tg"
+  | "th"
+  | "tj"
+  | "tk"
+  | "tl"
+  | "tm"
+  | "tn"
+  | "to"
+  | "tp"
+  | "tr"
+  | "tt"
+  | "tv"
+  | "tw"
+  | "tz"
+  | "ua"
+  | "ug"
+  | "uk"
+  | "um"
+  | "us"
+  | "uy"
+  | "uz"
+  | "va"
+  | "vc"
+  | "ve"
+  | "vg"
+  | "vi"
+  | "vn"
+  | "vu"
+  | "we"
+  | "wf"
+  | "ws"
+  | "ye"
+  | "yt"
+  | "yu"
+  | "za"
+  | "zm"
+  | "zw";
+export const CoreTypesCountryEnum = /*@__PURE__*/ S.String;
+
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = { [key: string]: string | undefined };
+export const IamResourceMetadataTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<IamResourceMetadataTagsMap>;
+
+/** IAM resource metadata embedded in services models */
+export interface IamResourceMetadata {
+  /** Resource display name */
+  displayName?: string | null;
+  /** Unique identifier of the resource */
+  id?: string;
+  /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+  tags?: IamResourceMetadataTagsMap | null;
+  /** Unique resource name used in policies */
+  urn?: string;
+}
+export const IamResourceMetadata = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.String),
+    tags: S.optional(S.NullOr(IamResourceMetadataTagsMap)),
+    urn: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "IamResourceMetadata",
+}) as any as S.Schema<IamResourceMetadata>;
+
+/** Region names */
+export type CoreTypesRegionCodenameEnum =
+  | "af-central-lz-abj"
+  | "af-north-lz-rba"
+  | "ap-south-lz-akl"
+  | "ap-south-lz-blr"
+  | "ap-south-lz-icd"
+  | "ap-south-mum"
+  | "ap-southeast-sgp"
+  | "ap-southeast-syd"
+  | "ca-east-bhs"
+  | "ca-east-tor"
+  | "eu-central-lz-buh"
+  | "eu-central-lz-sof"
+  | "eu-central-waw"
+  | "eu-east-lz-prg"
+  | "eu-north-lz-cph"
+  | "eu-north-lz-hel"
+  | "eu-north-lz-osl"
+  | "eu-north-lz-sto"
+  | "eu-south-lz-lis"
+  | "eu-south-lz-mad"
+  | "eu-south-lz-mil"
+  | "eu-south-mil"
+  | "eu-west-eri"
+  | "eu-west-gra"
+  | "eu-west-lim"
+  | "eu-west-lz-ams"
+  | "eu-west-lz-bru"
+  | "eu-west-lz-dln"
+  | "eu-west-lz-lux"
+  | "eu-west-lz-mnc"
+  | "eu-west-lz-mrs"
+  | "eu-west-lz-vie"
+  | "eu-west-lz-zrh"
+  | "eu-west-par"
+  | "eu-west-rbx"
+  | "eu-west-sbg"
+  | "me-south-lz-dxb"
+  | "sa-central-lz-mex"
+  | "sa-east-lz-sao"
+  | "sa-west-lz-bue"
+  | "sa-west-lz-scl"
+  | "us-central-lz-slc"
+  | "us-central-lz-stl"
+  | "us-east-lz-atl"
+  | "us-east-lz-bos"
+  | "us-east-lz-chi"
+  | "us-east-lz-dal"
+  | "us-east-lz-mia"
+  | "us-east-lz-nyc"
+  | "us-east-vin"
+  | "us-west-hil"
+  | "us-west-lz-den"
+  | "us-west-lz-lax"
+  | "us-west-lz-pao"
+  | "us-west-lz-phx"
+  | "us-west-lz-sea";
+export const CoreTypesRegionCodenameEnum = /*@__PURE__*/ S.String;
+
+/** Where is the IP used/usable, in the form of region codenames (alpha) */
+export type IpIpWithIAMRegionsList = Array<CoreTypesRegionCodenameEnum>;
+export const IpIpWithIAMRegionsList = /*@__PURE__*/ S.Array(
+  CoreTypesRegionCodenameEnum,
+) as any as S.Schema<IpIpWithIAMRegionsList>;
+
+/** Possible values for ip type */
+export type IpIpTypeEnum =
+  | "cdn"
+  | "cloud"
+  | "dedicated"
+  | "failover"
+  | "hosted_ssl"
+  | "housing"
+  | "loadBalancing"
+  | "mail"
+  | "overthebox"
+  | "pcc"
+  | "pci"
+  | "private"
+  | "vpn"
+  | "vps"
+  | "vrack"
+  | "xdsl";
+export const IpIpTypeEnum = /*@__PURE__*/ S.String;
+
+/** Possible values for IP version */
+export type IpIpVersionEnum = 4 | 6;
+export const IpIpVersionEnum = /*@__PURE__*/ S.Number;
+
+/** Your IP */
+export interface IpIpWithIAM {
+  /** Is this IP part of the Bring your own IP program (alpha) */
+  bringYourOwnIp?: boolean;
+  /** Where is the IP used/usable (alpha) */
+  campus?: string | null;
+  canBeTerminated?: boolean;
+  country?: CoreTypesCountryEnum | null;
+  /** Custom description on your ip */
+  description?: string | null;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  ip?: string;
+  /** Is this IP an Additional IP (alpha) */
+  isAdditionalIp?: boolean;
+  /** IP block organisation Id */
+  organisationId?: string | null;
+  /** Where is the IP used/usable, in the form of region codenames (alpha) */
+  regions?: IpIpWithIAMRegionsList | null;
+  /** Regional Internet Registry of the IP (alpha) */
+  rir?: string | null;
+  /** Routage information */
+  routedTo?: IpRoutedTo | null;
+  type?: IpIpTypeEnum;
+  /** Version of the IP (alpha) */
+  version?: IpIpVersionEnum;
+}
+export const IpIpWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bringYourOwnIp: S.optional(S.Boolean),
+    campus: S.optional(S.NullOr(S.String)),
+    canBeTerminated: S.optional(S.Boolean),
+    country: S.optional(S.NullOr(CoreTypesCountryEnum)),
+    description: S.optional(S.NullOr(S.String)),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    ip: S.optional(S.String),
+    isAdditionalIp: S.optional(S.Boolean),
+    organisationId: S.optional(S.NullOr(S.String)),
+    regions: S.optional(S.NullOr(IpIpWithIAMRegionsList)),
+    rir: S.optional(S.NullOr(S.String)),
+    routedTo: S.optional(S.NullOr(IpRoutedTo)),
+    type: S.optional(IpIpTypeEnum),
+    version: S.optional(IpIpVersionEnum),
+  }),
+).annotate({ identifier: "IpIpWithIAM" }) as any as S.Schema<IpIpWithIAM>;
+
+export interface GetIpAntihackRequest {
+  ip: string;
+  /** your IP */
+  ipBlocked: string;
+}
+export const GetIpAntihackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipBlocked: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/antihack/{ipBlocked}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpAntihackRequest",
+}) as any as S.Schema<GetIpAntihackRequest>;
+
+/** Possible values for IP state */
+export type IpBlockedIpStateEnum = "blocked" | "unblocking";
+export const IpBlockedIpStateEnum = /*@__PURE__*/ S.String;
+
+/** Blocked IP information */
+export interface IpBlockedIp {
+  /** The last blocking date */
+  blockedSince?: string;
+  /** your IP */
+  ipBlocked?: string;
+  /** Logs */
+  logs?: string | null;
+  /** this IP address state */
+  state?: IpBlockedIpStateEnum;
+  /** Time (in seconds) remaining before you can request your IP to be unblocked */
+  time?: number;
+}
+export const IpBlockedIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    blockedSince: S.optional(S.String),
+    ipBlocked: S.optional(S.String),
+    logs: S.optional(S.NullOr(S.String)),
+    state: S.optional(IpBlockedIpStateEnum),
+    time: S.optional(S.Number),
+  }),
+).annotate({ identifier: "IpBlockedIp" }) as any as S.Schema<IpBlockedIp>;
+
+export interface GetIpArpRequest {
+  ip: string;
+  /** your IP */
+  ipBlocked: string;
+}
+export const GetIpArpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipBlocked: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/arp/{ipBlocked}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpArpRequest",
+}) as any as S.Schema<GetIpArpRequest>;
+
+/** Possible values for IP state */
+export type IpArpStateEnum = "blocked" | "unblocking";
+export const IpArpStateEnum = /*@__PURE__*/ S.String;
+
+/** ARP blocked IP information */
+export interface IpArpBlockedIp {
+  /** The last blocking date */
+  blockedSince?: string;
+  /** your IP */
+  ipBlocked?: string;
+  /** ARP logs */
+  logs?: string | null;
+  /** this IP address state */
+  state?: IpArpStateEnum;
+  /** Time (in seconds) remaining before you can request your IP to be unblocked */
+  time?: number;
+}
+export const IpArpBlockedIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    blockedSince: S.optional(S.String),
+    ipBlocked: S.optional(S.String),
+    logs: S.optional(S.NullOr(S.String)),
+    state: S.optional(IpArpStateEnum),
+    time: S.optional(S.Number),
+  }),
+).annotate({ identifier: "IpArpBlockedIp" }) as any as S.Schema<IpArpBlockedIp>;
+
+export interface GetIpDelegationRequest {
+  ip: string;
+  /** NS target for delegation */
+  target: string;
+}
+export const GetIpDelegationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    target: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/delegation/{target}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpDelegationRequest",
+}) as any as S.Schema<GetIpDelegationRequest>;
+
+export interface GetIpFirewallRequest {
+  ip: string;
+  ipOnFirewall: string;
+}
+export const GetIpFirewallRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIpFirewallRequest",
+}) as any as S.Schema<GetIpFirewallRequest>;
+
+export interface GetIpFirewallRuleRequest {
+  ip: string;
+  ipOnFirewall: string;
+  sequence: number;
+}
+export const GetIpFirewallRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+    sequence: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}/rule/{sequence}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIpFirewallRuleRequest",
+}) as any as S.Schema<GetIpFirewallRuleRequest>;
+
+export interface GetIpGameRequest {
+  ip: string;
+  ipOnGame: string;
+}
+export const GetIpGameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnGame: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/game/{ipOnGame}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpGameRequest",
+}) as any as S.Schema<GetIpGameRequest>;
+
+/** Possible values for udp mitigation rule state */
+export type IpGameMitigationStateEnum =
+  | "cleanRulesPending"
+  | "firewallModeDisablePending"
+  | "firewallModeEnablePending"
+  | "ok";
+export const IpGameMitigationStateEnum = /*@__PURE__*/ S.String;
+
+/** List of protocols available on this IP */
+export type IpGameMitigationSupportedProtocolsList =
+  Array<IpGameMitigationRuleProtocolEnum>;
+export const IpGameMitigationSupportedProtocolsList = /*@__PURE__*/ S.Array(
+  IpGameMitigationRuleProtocolEnum,
+) as any as S.Schema<IpGameMitigationSupportedProtocolsList>;
+
+/** GAME Anti-DDoS */
+export interface IpGameMitigation {
+  /** Firewall mode : in UDP, only allow traffic matching your rules (as well as established traffic). If not enabled, traffic to ports not defined in your rules will be permited. TCP traffic is unaffected by this. */
+  firewallModeEnabled?: boolean;
+  ipOnGame?: string;
+  /** Maximum number of rules for this IP */
+  maxRules?: number;
+  state?: IpGameMitigationStateEnum;
+  /** List of protocols available on this IP */
+  supportedProtocols?: IpGameMitigationSupportedProtocolsList;
+}
+export const IpGameMitigation = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    firewallModeEnabled: S.optional(S.Boolean),
+    ipOnGame: S.optional(S.String),
+    maxRules: S.optional(S.Number),
+    state: S.optional(IpGameMitigationStateEnum),
+    supportedProtocols: S.optional(IpGameMitigationSupportedProtocolsList),
+  }),
+).annotate({
+  identifier: "IpGameMitigation",
+}) as any as S.Schema<IpGameMitigation>;
+
+export interface GetIpGameRuleRequest {
+  ip: string;
+  ipOnGame: string;
+  /** ID of the rule */
+  id: number;
+}
+export const GetIpGameRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnGame: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/game/{ipOnGame}/rule/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIpGameRuleRequest",
+}) as any as S.Schema<GetIpGameRuleRequest>;
+
+export interface GetIpMigrationTokenRequest {
+  ip: string;
+}
+export const GetIpMigrationTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/migrationToken", code: 200 })),
+).annotate({
+  identifier: "GetIpMigrationTokenRequest",
+}) as any as S.Schema<GetIpMigrationTokenRequest>;
+
+export interface GetIpMitigationRequest {
+  ip: string;
+  ipOnMitigation: string;
+}
+export const GetIpMitigationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnMitigation: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/mitigation/{ipOnMitigation}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIpMitigationRequest",
+}) as any as S.Schema<GetIpMitigationRequest>;
+
+export interface GetIpMitigationProfileRequest {
+  ip: string;
+  ipMitigationProfile: string;
+}
+export const GetIpMitigationProfileRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipMitigationProfile: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/mitigationProfiles/{ipMitigationProfile}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIpMitigationProfileRequest",
+}) as any as S.Schema<GetIpMitigationProfileRequest>;
+
+export interface GetIpPhishingRequest {
+  ip: string;
+  /** Internal ID of the phishing entry */
+  id: number;
+}
+export const GetIpPhishingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/phishing/{id}", code: 200 })),
+).annotate({
+  identifier: "GetIpPhishingRequest",
+}) as any as S.Schema<GetIpPhishingRequest>;
+
+/** Possible values for antiphishing state */
+export type IpAntiphishingStateEnum =
+  | "blocked"
+  | "blocking"
+  | "unblocked"
+  | "unblocking";
+export const IpAntiphishingStateEnum = /*@__PURE__*/ S.String;
+
+/** Phishing URLs hosted on your IP */
+export interface IpAntiphishing {
+  /** Date of the event */
+  creationDate?: string;
+  /** Internal ID of the phishing entry */
+  id?: number;
+  /** IP address hosting the phishing URL */
+  ipOnAntiphishing?: string;
+  /** Current state of the phishing */
+  state?: IpAntiphishingStateEnum;
+  /** Phishing URL */
+  urlPhishing?: string;
+}
+export const IpAntiphishing = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    id: S.optional(S.Number),
+    ipOnAntiphishing: S.optional(S.String),
+    state: S.optional(IpAntiphishingStateEnum),
+    urlPhishing: S.optional(S.String),
+  }),
+).annotate({ identifier: "IpAntiphishing" }) as any as S.Schema<IpAntiphishing>;
+
+export interface GetIpReverseRequest {
+  ip: string;
+  ipReverse: string;
+}
+export const GetIpReverseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipReverse: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/reverse/{ipReverse}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpReverseRequest",
+}) as any as S.Schema<GetIpReverseRequest>;
+
+export interface GetIpRipeRequest {
+  ip: string;
+}
+export const GetIpRipeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/ripe", code: 200 })),
+).annotate({
+  identifier: "GetIpRipeRequest",
+}) as any as S.Schema<GetIpRipeRequest>;
+
+/** IP block RIPE informations */
+export interface IpRipeInfos {
+  description?: string | null;
+  netname?: string | null;
+}
+export const IpRipeInfos = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.NullOr(S.String)),
+    netname: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "IpRipeInfos" }) as any as S.Schema<IpRipeInfos>;
+
+export interface GetIpServiceRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+}
+export const GetIpServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/service/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpServiceRequest",
+}) as any as S.Schema<GetIpServiceRequest>;
+
+/** Your IP linked to service */
+export interface IpServiceIpWithIAM {
+  canBeTerminated?: boolean;
+  country?: CoreTypesCountryEnum | null;
+  /** Custom description on your ip */
+  description?: string | null;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  ip?: string;
+  /** IP block organisation Id */
+  organisationId?: string | null;
+  /** Routage information */
+  routedTo?: IpRoutedTo | null;
+  type?: IpIpTypeEnum;
+}
+export const IpServiceIpWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canBeTerminated: S.optional(S.Boolean),
+    country: S.optional(S.NullOr(CoreTypesCountryEnum)),
+    description: S.optional(S.NullOr(S.String)),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    ip: S.optional(S.String),
+    organisationId: S.optional(S.NullOr(S.String)),
+    routedTo: S.optional(S.NullOr(IpRoutedTo)),
+    type: S.optional(IpIpTypeEnum),
+  }),
+).annotate({
+  identifier: "IpServiceIpWithIAM",
+}) as any as S.Schema<IpServiceIpWithIAM>;
+
+export interface GetIpServiceServiceInfosRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+}
+export const GetIpServiceServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/service/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIpServiceServiceInfosRequest",
+}) as any as S.Schema<GetIpServiceServiceInfosRequest>;
+
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export const ServicesServicePossibleRenewPeriodList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ServicesServicePossibleRenewPeriodList>;
+
+/** Map a possible renew for a specific service */
+export interface ServiceRenewType {
+  /** The service is automatically renewed */
+  automatic?: boolean;
+  /** The service will be deleted at expiration */
+  deleteAtExpiration?: boolean;
+  /** The service forced to be renewed */
+  forced?: boolean;
+  /** The service needs to be manually renewed and paid */
+  manualPayment?: boolean | null;
+  /** period of renew in month */
+  period?: number | null;
+}
+export const ServiceRenewType = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    automatic: S.optional(S.Boolean),
+    deleteAtExpiration: S.optional(S.Boolean),
+    forced: S.optional(S.Boolean),
+    manualPayment: S.optional(S.NullOr(S.Boolean)),
+    period: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "ServiceRenewType",
+}) as any as S.Schema<ServiceRenewType>;
+
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum =
+  | "automaticForcedProduct"
+  | "automaticV2012"
+  | "automaticV2014"
+  | "automaticV2016"
+  | "automaticV2024"
+  | "manual"
+  | "oneShot"
+  | "option";
+export const ServiceRenewalTypeEnum = /*@__PURE__*/ S.String;
+
+export type ServiceStateEnum =
+  | "autorenewInProgress"
+  | "expired"
+  | "inCreation"
+  | "ok"
+  | "pendingDebt"
+  | "unPaid";
+export const ServiceStateEnum = /*@__PURE__*/ S.String;
+
+/** Details about a Service */
+export interface ServicesService {
+  /** Indicates that the service can be set up to be deleted at expiration */
+  canDeleteAtExpiration?: boolean;
+  contactAdmin?: string;
+  contactBilling?: string;
+  contactTech?: string;
+  creation?: string;
+  domain?: string;
+  engagedUpTo?: string | null;
+  expiration?: string;
+  /** All the possible renew period of your service in month */
+  possibleRenewPeriod?: ServicesServicePossibleRenewPeriodList | null;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+  renewalType?: ServiceRenewalTypeEnum;
+  serviceId?: number;
+  status?: ServiceStateEnum;
+}
+export const ServicesService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canDeleteAtExpiration: S.optional(S.Boolean),
+    contactAdmin: S.optional(S.String),
+    contactBilling: S.optional(S.String),
+    contactTech: S.optional(S.String),
+    creation: S.optional(S.String),
+    domain: S.optional(S.String),
+    engagedUpTo: S.optional(S.NullOr(S.String)),
+    expiration: S.optional(S.String),
+    possibleRenewPeriod: S.optional(
+      S.NullOr(ServicesServicePossibleRenewPeriodList),
+    ),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+    renewalType: S.optional(ServiceRenewalTypeEnum),
+    serviceId: S.optional(S.Number),
+    status: S.optional(ServiceStateEnum),
+  }),
+).annotate({
+  identifier: "ServicesService",
+}) as any as S.Schema<ServicesService>;
+
+export interface GetIpSpamRequest {
+  ip: string;
+  /** IP address which is sending spam */
+  ipSpamming: string;
+}
+export const GetIpSpamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipSpamming: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/spam/{ipSpamming}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetIpSpamRequest",
+}) as any as S.Schema<GetIpSpamRequest>;
+
+/** Possible values for spam state */
+export type IpSpamStateEnum = "blockedForSpam" | "unblocked" | "unblocking";
+export const IpSpamStateEnum = /*@__PURE__*/ S.String;
+
+/** Your IP spam stats */
+export interface IpSpamIp {
+  /** Last date the ip was blocked */
+  date?: string;
+  /** IP address which is sending spam */
+  ipSpamming?: string;
+  /** Current state of the ip */
+  state?: IpSpamStateEnum;
+  /** Time (in seconds) while the IP will be blocked */
+  time?: number;
+}
+export const IpSpamIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    date: S.optional(S.String),
+    ipSpamming: S.optional(S.String),
+    state: S.optional(IpSpamStateEnum),
+    time: S.optional(S.Number),
+  }),
+).annotate({ identifier: "IpSpamIp" }) as any as S.Schema<IpSpamIp>;
+
+export interface GetIpTaskRequest {
+  ip: string;
+  /** the id of the task */
+  taskId: number;
+}
+export const GetIpTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    taskId: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/task/{taskId}", code: 200 })),
+).annotate({
+  identifier: "GetIpTaskRequest",
+}) as any as S.Schema<GetIpTaskRequest>;
+
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {}
+export const IamResourceTagFilterInput = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IamResourceTagFilterInput",
+}) as any as S.Schema<IamResourceTagFilterInput>;
+
+export type ListIpRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export const ListIpRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListIpRequestIamTagsValueList>;
+
+export type ListIpRequestIamTagsMap = {
+  [key: string]: ListIpRequestIamTagsValueList | undefined;
+};
+export const ListIpRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListIpRequestIamTagsValueList,
+) as any as S.Schema<ListIpRequestIamTagsMap>;
+
+export interface ListIpRequest {
+  /** Filter the value of campus property (ilike) (alpha) */
+  campus?: string;
+  /** Filter the value of description property (like) */
+  description?: string;
+  /** Filter resources on IAM tags */
+  iamTags?: ListIpRequestIamTagsMap;
+  /** Filter the value of ip property (contains or equals) */
+  ip?: string;
+  /** Filter the value of isAdditionalIp property (=) (alpha) */
+  isAdditionalIp?: boolean;
+  /** Filter the value of routedTo.serviceName property (like) */
+  routedTo_serviceName?: string;
+  /** Filter the value of type property (=) */
+  type?: IpIpTypeEnum | (string & {});
+  /** Filter the value of version property (=) (alpha) */
+  version?: IpIpVersionEnum | (number & {});
+}
+export const ListIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    campus: S.optional(S.String.pipe(T.Query())),
+    description: S.optional(S.String.pipe(T.Query())),
+    iamTags: S.optional(ListIpRequestIamTagsMap.pipe(T.Query())),
+    ip: S.optional(S.String.pipe(T.Query())),
+    isAdditionalIp: S.optional(S.Boolean.pipe(T.Query())),
+    routedTo_serviceName: S.optional(
+      S.String.pipe(T.Query("routedTo.serviceName")),
+    ),
+    type: S.optional(IpIpTypeEnum.pipe(T.Query())),
+    version: S.optional(IpIpVersionEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip", code: 200 })),
+).annotate({ identifier: "ListIpRequest" }) as any as S.Schema<ListIpRequest>;
+
+export type ListIpResponseBodyList = Array<string>;
+export const ListIpResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpResponseBodyList>;
+
+export type ListIpResponse = ListIpResponseBodyList;
+export const ListIpResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({ identifier: "ListIpResponse" }) as any as S.Schema<ListIpResponse>;
+
+export interface ListIpAntihackRequest {
+  ip: string;
+  /** Filter the value of state property (=) */
+  state?: IpBlockedIpStateEnum | (string & {});
+}
+export const ListIpAntihackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    state: S.optional(IpBlockedIpStateEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/antihack", code: 200 })),
+).annotate({
+  identifier: "ListIpAntihackRequest",
+}) as any as S.Schema<ListIpAntihackRequest>;
+
+export type ListIpAntihackResponseBodyList = Array<string>;
+export const ListIpAntihackResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpAntihackResponseBodyList>;
+
+export type ListIpAntihackResponse = ListIpAntihackResponseBodyList;
+export const ListIpAntihackResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpAntihackResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpAntihackResponse",
+}) as any as S.Schema<ListIpAntihackResponse>;
+
+export interface ListIpArpRequest {
+  ip: string;
+  /** Filter the value of state property (=) */
+  state?: IpArpStateEnum | (string & {});
+}
+export const ListIpArpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    state: S.optional(IpArpStateEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/arp", code: 200 })),
+).annotate({
+  identifier: "ListIpArpRequest",
+}) as any as S.Schema<ListIpArpRequest>;
+
+export type ListIpArpResponseBodyList = Array<string>;
+export const ListIpArpResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpArpResponseBodyList>;
+
+export type ListIpArpResponse = ListIpArpResponseBodyList;
+export const ListIpArpResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpArpResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpArpResponse",
+}) as any as S.Schema<ListIpArpResponse>;
+
+export interface ListIpBringYourOwnIpAggregateRequest {
+  ip: string;
+}
+export const ListIpBringYourOwnIpAggregateRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      ip: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/ip/{ip}/bringYourOwnIp/aggregate",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListIpBringYourOwnIpAggregateRequest",
+}) as any as S.Schema<ListIpBringYourOwnIpAggregateRequest>;
+
+/** Existing Additional IP(s) that will be aggregated */
+export type IpByoipAggregationPreviewChildrenIpsList = Array<string>;
+export const IpByoipAggregationPreviewChildrenIpsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<IpByoipAggregationPreviewChildrenIpsList>;
+
+/** Preview of an IP aggregation on BYOIP Additional IPs */
+export interface IpByoipAggregationPreview {
+  /** Aggregation Additional IP that will be created */
+  aggregationIp?: string;
+  /** Existing Additional IP(s) that will be aggregated */
+  childrenIps?: IpByoipAggregationPreviewChildrenIpsList;
+}
+export const IpByoipAggregationPreview = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    aggregationIp: S.optional(S.String),
+    childrenIps: S.optional(IpByoipAggregationPreviewChildrenIpsList),
+  }),
+).annotate({
+  identifier: "IpByoipAggregationPreview",
+}) as any as S.Schema<IpByoipAggregationPreview>;
+
+export type ListIpBringYourOwnIpAggregateResponseBodyList =
+  Array<IpByoipAggregationPreview>;
+export const ListIpBringYourOwnIpAggregateResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    IpByoipAggregationPreview,
+  ) as any as S.Schema<ListIpBringYourOwnIpAggregateResponseBodyList>;
+
+export type ListIpBringYourOwnIpAggregateResponse =
+  ListIpBringYourOwnIpAggregateResponseBodyList;
+export const ListIpBringYourOwnIpAggregateResponse = /*@__PURE__*/ S.suspend(
+  () => ListIpBringYourOwnIpAggregateResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpBringYourOwnIpAggregateResponse",
+}) as any as S.Schema<ListIpBringYourOwnIpAggregateResponse>;
+
+export interface ListIpBringYourOwnIpSliceRequest {
+  ip: string;
+}
+export const ListIpBringYourOwnIpSliceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/bringYourOwnIp/slice", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpBringYourOwnIpSliceRequest",
+}) as any as S.Schema<ListIpBringYourOwnIpSliceRequest>;
+
+/** Additional IP(s) that will be created */
+export type IpByoipSlicingPreviewChildrenIpsList = Array<string>;
+export const IpByoipSlicingPreviewChildrenIpsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<IpByoipSlicingPreviewChildrenIpsList>;
+
+/** Preview of an IP slicing on BYOIP Additional IPs */
+export interface IpByoipSlicingPreview {
+  /** Additional IP(s) that will be created */
+  childrenIps?: IpByoipSlicingPreviewChildrenIpsList;
+  /** Slicing size */
+  slicingSize?: number;
+}
+export const IpByoipSlicingPreview = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    childrenIps: S.optional(IpByoipSlicingPreviewChildrenIpsList),
+    slicingSize: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "IpByoipSlicingPreview",
+}) as any as S.Schema<IpByoipSlicingPreview>;
+
+export type ListIpBringYourOwnIpSliceResponseBodyList =
+  Array<IpByoipSlicingPreview>;
+export const ListIpBringYourOwnIpSliceResponseBodyList = /*@__PURE__*/ S.Array(
+  IpByoipSlicingPreview,
+) as any as S.Schema<ListIpBringYourOwnIpSliceResponseBodyList>;
+
+export type ListIpBringYourOwnIpSliceResponse =
+  ListIpBringYourOwnIpSliceResponseBodyList;
+export const ListIpBringYourOwnIpSliceResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpBringYourOwnIpSliceResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpBringYourOwnIpSliceResponse",
+}) as any as S.Schema<ListIpBringYourOwnIpSliceResponse>;
+
+export interface ListIpCampusRequest {}
+export const ListIpCampusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/ip/campus", code: 200 })),
+).annotate({
+  identifier: "ListIpCampusRequest",
+}) as any as S.Schema<ListIpCampusRequest>;
+
+/** List of RIRs whose IPs can be imported in the campus */
+export type IpCampusBringYourOwnIpSupportedRirForIpList = Array<string>;
+export const IpCampusBringYourOwnIpSupportedRirForIpList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<IpCampusBringYourOwnIpSupportedRirForIpList>;
+
+/** ovh datacenter */
+export type DedicatedDatacenterEnum =
+  | "bhs1"
+  | "bhs2"
+  | "bhs3"
+  | "bhs4"
+  | "bhs5"
+  | "bhs6"
+  | "bhs7"
+  | "bhs8"
+  | "cch01"
+  | "crx1"
+  | "crx2"
+  | "dc1"
+  | "eri1"
+  | "eri2"
+  | "gra04"
+  | "gra1"
+  | "gra2"
+  | "gra3"
+  | "gsw"
+  | "hdf01"
+  | "hil1"
+  | "ieb01"
+  | "lil1-int1"
+  | "lim1"
+  | "lim2"
+  | "lim3"
+  | "mr901"
+  | "p19"
+  | "rbx"
+  | "rbx-hz"
+  | "rbx1"
+  | "rbx10"
+  | "rbx2"
+  | "rbx3"
+  | "rbx4"
+  | "rbx5"
+  | "rbx6"
+  | "rbx7"
+  | "rbx8"
+  | "rbx9"
+  | "sbg1"
+  | "sbg2"
+  | "sbg3"
+  | "sbg4"
+  | "sbg5"
+  | "sgp02"
+  | "sgp1"
+  | "syd03"
+  | "syd1"
+  | "syd2"
+  | "vin1"
+  | "waw1"
+  | "ynm1"
+  | "yyz01";
+export const DedicatedDatacenterEnum = /*@__PURE__*/ S.String;
+
+/** List of datacenters in the campus */
+export type IpCampusDatacentersList = Array<DedicatedDatacenterEnum>;
+export const IpCampusDatacentersList = /*@__PURE__*/ S.Array(
+  DedicatedDatacenterEnum,
+) as any as S.Schema<IpCampusDatacentersList>;
+
+/** Possible values for IP campuses' names */
+export type IpCampusEnum =
+  | "BHS"
+  | "ERI"
+  | "GRA"
+  | "HIL"
+  | "LIM"
+  | "PAR"
+  | "RBX"
+  | "SBG"
+  | "SGP"
+  | "SYD"
+  | "VIN"
+  | "WAW"
+  | "YNM"
+  | "YYZ";
+export const IpCampusEnum = /*@__PURE__*/ S.String;
+
+/** Campus of an IP address */
+export interface IpCampus {
+  /** List of RIRs whose IPs can be imported in the campus */
+  bringYourOwnIpSupportedRirForIp?: IpCampusBringYourOwnIpSupportedRirForIpList;
+  /** List of datacenters in the campus */
+  datacenters?: IpCampusDatacentersList;
+  /** Description of the campus */
+  description?: string;
+  /** Campus name */
+  name?: IpCampusEnum;
+}
+export const IpCampus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bringYourOwnIpSupportedRirForIp: S.optional(
+      IpCampusBringYourOwnIpSupportedRirForIpList,
+    ),
+    datacenters: S.optional(IpCampusDatacentersList),
+    description: S.optional(S.String),
+    name: S.optional(IpCampusEnum),
+  }),
+).annotate({ identifier: "IpCampus" }) as any as S.Schema<IpCampus>;
+
+export type ListIpCampusResponseBodyList = Array<IpCampus>;
+export const ListIpCampusResponseBodyList = /*@__PURE__*/ S.Array(
+  IpCampus,
+) as any as S.Schema<ListIpCampusResponseBodyList>;
+
+export type ListIpCampusResponse = ListIpCampusResponseBodyList;
+export const ListIpCampusResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpCampusResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpCampusResponse",
+}) as any as S.Schema<ListIpCampusResponse>;
+
+export interface ListIpDelegationRequest {
+  ip: string;
+}
+export const ListIpDelegationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/delegation", code: 200 })),
+).annotate({
+  identifier: "ListIpDelegationRequest",
+}) as any as S.Schema<ListIpDelegationRequest>;
+
+export type ListIpDelegationResponseBodyList = Array<string>;
+export const ListIpDelegationResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpDelegationResponseBodyList>;
+
+export type ListIpDelegationResponse = ListIpDelegationResponseBodyList;
+export const ListIpDelegationResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpDelegationResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpDelegationResponse",
+}) as any as S.Schema<ListIpDelegationResponse>;
+
+export interface ListIpFirewallRequest {
+  ip: string;
+  /** Filter the value of enabled property (=) */
+  enabled?: boolean;
+  /** Filter the value of state property (=) */
+  state?: IpFirewallStateEnum | (string & {});
+}
+export const ListIpFirewallRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    enabled: S.optional(S.Boolean.pipe(T.Query())),
+    state: S.optional(IpFirewallStateEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/firewall", code: 200 })),
+).annotate({
+  identifier: "ListIpFirewallRequest",
+}) as any as S.Schema<ListIpFirewallRequest>;
+
+export type ListIpFirewallResponseBodyList = Array<string>;
+export const ListIpFirewallResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpFirewallResponseBodyList>;
+
+export type ListIpFirewallResponse = ListIpFirewallResponseBodyList;
+export const ListIpFirewallResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpFirewallResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpFirewallResponse",
+}) as any as S.Schema<ListIpFirewallResponse>;
+
+export interface ListIpFirewallRuleRequest {
+  ip: string;
+  ipOnFirewall: string;
+  /** Filter the value of state property (=) */
+  state?: IpFirewallRuleStateEnum | (string & {});
+}
+export const ListIpFirewallRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+    state: S.optional(IpFirewallRuleStateEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}/rule",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListIpFirewallRuleRequest",
+}) as any as S.Schema<ListIpFirewallRuleRequest>;
+
+export type ListIpFirewallRuleResponseBodyList = Array<number>;
+export const ListIpFirewallRuleResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListIpFirewallRuleResponseBodyList>;
+
+export type ListIpFirewallRuleResponse = ListIpFirewallRuleResponseBodyList;
+export const ListIpFirewallRuleResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpFirewallRuleResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpFirewallRuleResponse",
+}) as any as S.Schema<ListIpFirewallRuleResponse>;
+
+export interface ListIpGameRequest {
+  ip: string;
+}
+export const ListIpGameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/game", code: 200 })),
+).annotate({
+  identifier: "ListIpGameRequest",
+}) as any as S.Schema<ListIpGameRequest>;
+
+export type ListIpGameResponseBodyList = Array<string>;
+export const ListIpGameResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpGameResponseBodyList>;
+
+export type ListIpGameResponse = ListIpGameResponseBodyList;
+export const ListIpGameResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpGameResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpGameResponse",
+}) as any as S.Schema<ListIpGameResponse>;
+
+export interface ListIpGameRuleRequest {
+  ip: string;
+  ipOnGame: string;
+}
+export const ListIpGameRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnGame: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/game/{ipOnGame}/rule", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpGameRuleRequest",
+}) as any as S.Schema<ListIpGameRuleRequest>;
+
+export type ListIpGameRuleResponseBodyList = Array<number>;
+export const ListIpGameRuleResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListIpGameRuleResponseBodyList>;
+
+export type ListIpGameRuleResponse = ListIpGameRuleResponseBodyList;
+export const ListIpGameRuleResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpGameRuleResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpGameRuleResponse",
+}) as any as S.Schema<ListIpGameRuleResponse>;
+
+export interface ListIpLicenseCloudLinuxRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseCloudLinuxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/license/cloudLinux", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpLicenseCloudLinuxRequest",
+}) as any as S.Schema<ListIpLicenseCloudLinuxRequest>;
+
+export type ListIpLicenseCloudLinuxResponseBodyList = Array<string>;
+export const ListIpLicenseCloudLinuxResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseCloudLinuxResponseBodyList>;
+
+export type ListIpLicenseCloudLinuxResponse =
+  ListIpLicenseCloudLinuxResponseBodyList;
+export const ListIpLicenseCloudLinuxResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseCloudLinuxResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseCloudLinuxResponse",
+}) as any as S.Schema<ListIpLicenseCloudLinuxResponse>;
+
+export interface ListIpLicenseCpanelRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseCpanelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/license/cpanel", code: 200 })),
+).annotate({
+  identifier: "ListIpLicenseCpanelRequest",
+}) as any as S.Schema<ListIpLicenseCpanelRequest>;
+
+export type ListIpLicenseCpanelResponseBodyList = Array<string>;
+export const ListIpLicenseCpanelResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseCpanelResponseBodyList>;
+
+export type ListIpLicenseCpanelResponse = ListIpLicenseCpanelResponseBodyList;
+export const ListIpLicenseCpanelResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseCpanelResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseCpanelResponse",
+}) as any as S.Schema<ListIpLicenseCpanelResponse>;
+
+export interface ListIpLicenseDirectadminRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseDirectadminRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/license/directadmin", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpLicenseDirectadminRequest",
+}) as any as S.Schema<ListIpLicenseDirectadminRequest>;
+
+export type ListIpLicenseDirectadminResponseBodyList = Array<string>;
+export const ListIpLicenseDirectadminResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseDirectadminResponseBodyList>;
+
+export type ListIpLicenseDirectadminResponse =
+  ListIpLicenseDirectadminResponseBodyList;
+export const ListIpLicenseDirectadminResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseDirectadminResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseDirectadminResponse",
+}) as any as S.Schema<ListIpLicenseDirectadminResponse>;
+
+export interface ListIpLicensePleskRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicensePleskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/license/plesk", code: 200 })),
+).annotate({
+  identifier: "ListIpLicensePleskRequest",
+}) as any as S.Schema<ListIpLicensePleskRequest>;
+
+export type ListIpLicensePleskResponseBodyList = Array<string>;
+export const ListIpLicensePleskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicensePleskResponseBodyList>;
+
+export type ListIpLicensePleskResponse = ListIpLicensePleskResponseBodyList;
+export const ListIpLicensePleskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicensePleskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicensePleskResponse",
+}) as any as S.Schema<ListIpLicensePleskResponse>;
+
+export interface ListIpLicenseSqlserverRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseSqlserverRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/license/sqlserver", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpLicenseSqlserverRequest",
+}) as any as S.Schema<ListIpLicenseSqlserverRequest>;
+
+export type ListIpLicenseSqlserverResponseBodyList = Array<string>;
+export const ListIpLicenseSqlserverResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseSqlserverResponseBodyList>;
+
+export type ListIpLicenseSqlserverResponse =
+  ListIpLicenseSqlserverResponseBodyList;
+export const ListIpLicenseSqlserverResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseSqlserverResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseSqlserverResponse",
+}) as any as S.Schema<ListIpLicenseSqlserverResponse>;
+
+export interface ListIpLicenseVirtuozzoRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseVirtuozzoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/license/virtuozzo", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpLicenseVirtuozzoRequest",
+}) as any as S.Schema<ListIpLicenseVirtuozzoRequest>;
+
+export type ListIpLicenseVirtuozzoResponseBodyList = Array<string>;
+export const ListIpLicenseVirtuozzoResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseVirtuozzoResponseBodyList>;
+
+export type ListIpLicenseVirtuozzoResponse =
+  ListIpLicenseVirtuozzoResponseBodyList;
+export const ListIpLicenseVirtuozzoResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseVirtuozzoResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseVirtuozzoResponse",
+}) as any as S.Schema<ListIpLicenseVirtuozzoResponse>;
+
+export interface ListIpLicenseWindowsRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseWindowsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/license/windows", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpLicenseWindowsRequest",
+}) as any as S.Schema<ListIpLicenseWindowsRequest>;
+
+export type ListIpLicenseWindowsResponseBodyList = Array<string>;
+export const ListIpLicenseWindowsResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseWindowsResponseBodyList>;
+
+export type ListIpLicenseWindowsResponse = ListIpLicenseWindowsResponseBodyList;
+export const ListIpLicenseWindowsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseWindowsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseWindowsResponse",
+}) as any as S.Schema<ListIpLicenseWindowsResponse>;
+
+export interface ListIpLicenseWorklightRequest {
+  ip: string;
+  /** Filter the value of ipAddress property (=) */
+  ipAddress?: string;
+}
+export const ListIpLicenseWorklightRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipAddress: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/license/worklight", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpLicenseWorklightRequest",
+}) as any as S.Schema<ListIpLicenseWorklightRequest>;
+
+export type ListIpLicenseWorklightResponseBodyList = Array<string>;
+export const ListIpLicenseWorklightResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpLicenseWorklightResponseBodyList>;
+
+export type ListIpLicenseWorklightResponse =
+  ListIpLicenseWorklightResponseBodyList;
+export const ListIpLicenseWorklightResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpLicenseWorklightResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpLicenseWorklightResponse",
+}) as any as S.Schema<ListIpLicenseWorklightResponse>;
+
+export interface ListIpMitigationRequest {
+  ip: string;
+  /** Filter the value of auto property (=) */
+  auto?: boolean;
+  /** Filter the value of state property (=) */
+  state?: IpMitigationStateEnum | (string & {});
+}
+export const ListIpMitigationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    auto: S.optional(S.Boolean.pipe(T.Query())),
+    state: S.optional(IpMitigationStateEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/mitigation", code: 200 })),
+).annotate({
+  identifier: "ListIpMitigationRequest",
+}) as any as S.Schema<ListIpMitigationRequest>;
+
+export type ListIpMitigationResponseBodyList = Array<string>;
+export const ListIpMitigationResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpMitigationResponseBodyList>;
+
+export type ListIpMitigationResponse = ListIpMitigationResponseBodyList;
+export const ListIpMitigationResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpMitigationResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpMitigationResponse",
+}) as any as S.Schema<ListIpMitigationResponse>;
+
+export interface ListIpMitigationProfilesRequest {
+  ip: string;
+}
+export const ListIpMitigationProfilesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/ip/{ip}/mitigationProfiles", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIpMitigationProfilesRequest",
+}) as any as S.Schema<ListIpMitigationProfilesRequest>;
+
+export type ListIpMitigationProfilesResponseBodyList = Array<string>;
+export const ListIpMitigationProfilesResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpMitigationProfilesResponseBodyList>;
+
+export type ListIpMitigationProfilesResponse =
+  ListIpMitigationProfilesResponseBodyList;
+export const ListIpMitigationProfilesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpMitigationProfilesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpMitigationProfilesResponse",
+}) as any as S.Schema<ListIpMitigationProfilesResponse>;
+
+export interface ListIpMoveRequest {
+  ip: string;
+}
+export const ListIpMoveRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/move", code: 200 })),
+).annotate({
+  identifier: "ListIpMoveRequest",
+}) as any as S.Schema<ListIpMoveRequest>;
+
+/** Nexthops available on this service */
+export type IpDestinationNexthopList = Array<string>;
+export const IpDestinationNexthopList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<IpDestinationNexthopList>;
+
+/** A structure given service and its nexthops as a destination for failover ips */
+export interface IpDestination {
+  /** Nexthops available on this service */
+  nexthop?: IpDestinationNexthopList | null;
+  /** Service destination */
+  service?: string;
+}
+export const IpDestination = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    nexthop: S.optional(S.NullOr(IpDestinationNexthopList)),
+    service: S.optional(S.String),
+  }),
+).annotate({ identifier: "IpDestination" }) as any as S.Schema<IpDestination>;
+
+/** list of public cloud projects */
+export type IpDestinationsCloudProjectList = Array<IpDestination>;
+export const IpDestinationsCloudProjectList = /*@__PURE__*/ S.Array(
+  IpDestination,
+) as any as S.Schema<IpDestinationsCloudProjectList>;
+
+/** list of dedicated clouds */
+export type IpDestinationsDedicatedCloudList = Array<IpDestination>;
+export const IpDestinationsDedicatedCloudList = /*@__PURE__*/ S.Array(
+  IpDestination,
+) as any as S.Schema<IpDestinationsDedicatedCloudList>;
+
+/** list of dedicated servers */
+export type IpDestinationsDedicatedServerList = Array<IpDestination>;
+export const IpDestinationsDedicatedServerList = /*@__PURE__*/ S.Array(
+  IpDestination,
+) as any as S.Schema<IpDestinationsDedicatedServerList>;
+
+/** list of hosting reseller services */
+export type IpDestinationsHostingResellerList = Array<IpDestination>;
+export const IpDestinationsHostingResellerList = /*@__PURE__*/ S.Array(
+  IpDestination,
+) as any as S.Schema<IpDestinationsHostingResellerList>;
+
+/** list of load balancing services */
+export type IpDestinationsIpLoadbalancingList = Array<IpDestination>;
+export const IpDestinationsIpLoadbalancingList = /*@__PURE__*/ S.Array(
+  IpDestination,
+) as any as S.Schema<IpDestinationsIpLoadbalancingList>;
+
+/** list of vps */
+export type IpDestinationsVpsList = Array<IpDestination>;
+export const IpDestinationsVpsList = /*@__PURE__*/ S.Array(
+  IpDestination,
+) as any as S.Schema<IpDestinationsVpsList>;
+
+/** A structure given all services allowed as a destination for this ip */
+export interface IpDestinations {
+  /** list of public cloud projects */
+  cloudProject?: IpDestinationsCloudProjectList | null;
+  /** list of dedicated clouds */
+  dedicatedCloud?: IpDestinationsDedicatedCloudList | null;
+  /** list of dedicated servers */
+  dedicatedServer?: IpDestinationsDedicatedServerList | null;
+  /** list of hosting reseller services */
+  hostingReseller?: IpDestinationsHostingResellerList | null;
+  /** list of load balancing services */
+  ipLoadbalancing?: IpDestinationsIpLoadbalancingList | null;
+  /** list of vps */
+  vps?: IpDestinationsVpsList | null;
+}
+export const IpDestinations = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cloudProject: S.optional(S.NullOr(IpDestinationsCloudProjectList)),
+    dedicatedCloud: S.optional(S.NullOr(IpDestinationsDedicatedCloudList)),
+    dedicatedServer: S.optional(S.NullOr(IpDestinationsDedicatedServerList)),
+    hostingReseller: S.optional(S.NullOr(IpDestinationsHostingResellerList)),
+    ipLoadbalancing: S.optional(S.NullOr(IpDestinationsIpLoadbalancingList)),
+    vps: S.optional(S.NullOr(IpDestinationsVpsList)),
+  }),
+).annotate({ identifier: "IpDestinations" }) as any as S.Schema<IpDestinations>;
+
+export interface ListIpPhishingRequest {
+  ip: string;
+  /** Filter the value of ipOnAntiphishing property (within or equals) */
+  ipOnAntiphishing?: string;
+  /** Filter the value of state property (=) */
+  state?: IpAntiphishingStateEnum | (string & {});
+}
+export const ListIpPhishingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnAntiphishing: S.optional(S.String.pipe(T.Query())),
+    state: S.optional(IpAntiphishingStateEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/phishing", code: 200 })),
+).annotate({
+  identifier: "ListIpPhishingRequest",
+}) as any as S.Schema<ListIpPhishingRequest>;
+
+export type ListIpPhishingResponseBodyList = Array<number>;
+export const ListIpPhishingResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListIpPhishingResponseBodyList>;
+
+export type ListIpPhishingResponse = ListIpPhishingResponseBodyList;
+export const ListIpPhishingResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpPhishingResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpPhishingResponse",
+}) as any as S.Schema<ListIpPhishingResponse>;
+
+export interface ListIpReverseRequest {
+  ip: string;
+}
+export const ListIpReverseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/reverse", code: 200 })),
+).annotate({
+  identifier: "ListIpReverseRequest",
+}) as any as S.Schema<ListIpReverseRequest>;
+
+export type ListIpReverseResponseBodyList = Array<string>;
+export const ListIpReverseResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpReverseResponseBodyList>;
+
+export type ListIpReverseResponse = ListIpReverseResponseBodyList;
+export const ListIpReverseResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpReverseResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpReverseResponse",
+}) as any as S.Schema<ListIpReverseResponse>;
+
+export type ListIpServiceRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListIpServiceRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListIpServiceRequestIamTagsValueList>;
+
+export type ListIpServiceRequestIamTagsMap = {
+  [key: string]: ListIpServiceRequestIamTagsValueList | undefined;
+};
+export const ListIpServiceRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListIpServiceRequestIamTagsValueList,
+) as any as S.Schema<ListIpServiceRequestIamTagsMap>;
+
+export interface ListIpServiceRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListIpServiceRequestIamTagsMap;
+}
+export const ListIpServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListIpServiceRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/service", code: 200 })),
+).annotate({
+  identifier: "ListIpServiceRequest",
+}) as any as S.Schema<ListIpServiceRequest>;
+
+export type ListIpServiceResponseBodyList = Array<string>;
+export const ListIpServiceResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpServiceResponseBodyList>;
+
+export type ListIpServiceResponse = ListIpServiceResponseBodyList;
+export const ListIpServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpServiceResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpServiceResponse",
+}) as any as S.Schema<ListIpServiceResponse>;
+
+export interface ListIpSpamRequest {
+  ip: string;
+  /** Filter the value of state property (=) */
+  state?: IpSpamStateEnum | (string & {});
+}
+export const ListIpSpamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    state: S.optional(IpSpamStateEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/spam", code: 200 })),
+).annotate({
+  identifier: "ListIpSpamRequest",
+}) as any as S.Schema<ListIpSpamRequest>;
+
+export type ListIpSpamResponseBodyList = Array<string>;
+export const ListIpSpamResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListIpSpamResponseBodyList>;
+
+export type ListIpSpamResponse = ListIpSpamResponseBodyList;
+export const ListIpSpamResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpSpamResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpSpamResponse",
+}) as any as S.Schema<ListIpSpamResponse>;
+
+export interface ListIpSpamStatsRequest {
+  ip: string;
+  /** IP address which is sending spam */
+  ipSpamming: string;
+  /** Start date */
+  from: string;
+  /** End date */
+  to: string;
+}
+export const ListIpSpamStatsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipSpamming: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/ip/{ip}/spam/{ipSpamming}/stats",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListIpSpamStatsRequest",
+}) as any as S.Schema<ListIpSpamStatsRequest>;
+
+/** Spam's target information */
+export interface IpSpamTarget {
+  /** Timestamp when the email was sent */
+  date?: number;
+  /** IP address of the target */
+  destinationIp?: string;
+  /** The message-id of the email */
+  messageId?: string;
+  /** Spam score for the email */
+  spamscore?: number;
+}
+export const IpSpamTarget = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    date: S.optional(S.Number),
+    destinationIp: S.optional(S.String),
+    messageId: S.optional(S.String),
+    spamscore: S.optional(S.Number),
+  }),
+).annotate({ identifier: "IpSpamTarget" }) as any as S.Schema<IpSpamTarget>;
+
+/** Detailed list of the spams */
+export type IpSpamStatsDetectedSpamsList = Array<IpSpamTarget>;
+export const IpSpamStatsDetectedSpamsList = /*@__PURE__*/ S.Array(
+  IpSpamTarget,
+) as any as S.Schema<IpSpamStatsDetectedSpamsList>;
+
+/** Spam statistics about an IP address */
+export interface IpSpamStats {
+  /** Average spam score. */
+  averageSpamscore?: number | null;
+  /** Detailed list of the spams */
+  detectedSpams?: IpSpamStatsDetectedSpamsList | null;
+  /** Number of spams sent */
+  numberOfSpams?: number;
+  /** Time when the IP address was blocked */
+  timestamp?: number;
+  /** Number of emails sent */
+  total?: number;
+}
+export const IpSpamStats = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    averageSpamscore: S.optional(S.NullOr(S.Number)),
+    detectedSpams: S.optional(S.NullOr(IpSpamStatsDetectedSpamsList)),
+    numberOfSpams: S.optional(S.Number),
+    timestamp: S.optional(S.Number),
+    total: S.optional(S.Number),
+  }),
+).annotate({ identifier: "IpSpamStats" }) as any as S.Schema<IpSpamStats>;
+
+export type ListIpSpamStatsResponseBodyList = Array<IpSpamStats>;
+export const ListIpSpamStatsResponseBodyList = /*@__PURE__*/ S.Array(
+  IpSpamStats,
+) as any as S.Schema<ListIpSpamStatsResponseBodyList>;
+
+export type ListIpSpamStatsResponse = ListIpSpamStatsResponseBodyList;
+export const ListIpSpamStatsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpSpamStatsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpSpamStatsResponse",
+}) as any as S.Schema<ListIpSpamStatsResponse>;
+
+export interface ListIpTaskRequest {
+  ip: string;
+  /** Filter the value of function property (=) */
+  function?: IpTaskFunctionEnum | (string & {});
+  /** Filter the value of status property (=) */
+  status?: IpTaskStatusEnum | (string & {});
+}
+export const ListIpTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    function: S.optional(IpTaskFunctionEnum.pipe(T.Query())),
+    status: S.optional(IpTaskStatusEnum.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/ip/{ip}/task", code: 200 })),
+).annotate({
+  identifier: "ListIpTaskRequest",
+}) as any as S.Schema<ListIpTaskRequest>;
+
+export type ListIpTaskResponseBodyList = Array<number>;
+export const ListIpTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListIpTaskResponseBodyList>;
+
+export type ListIpTaskResponse = ListIpTaskResponseBodyList;
+export const ListIpTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIpTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIpTaskResponse",
+}) as any as S.Schema<ListIpTaskResponse>;
+
+export interface MoveIpRequest {
+  ip: string;
+  /** Nexthop of destination service */
+  nexthop?: string;
+  /** Service destination */
+  to: string;
+}
+export const MoveIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    nexthop: S.optional(S.String),
+    to: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/ip/{ip}/move", code: 200 })),
+).annotate({ identifier: "MoveIpRequest" }) as any as S.Schema<MoveIpRequest>;
+
+export interface PutIpRequest {
+  ip: string;
+  /** Custom description on your ip */
+  description?: string | null;
+}
+export const PutIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    description: S.optional(S.NullOr(S.String)),
+  }).pipe(T.Http({ method: "PUT", uri: "/ip/{ip}", code: 200 })),
+).annotate({ identifier: "PutIpRequest" }) as any as S.Schema<PutIpRequest>;
+
+export interface PutIpResponse {}
+export const PutIpResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({ identifier: "PutIpResponse" }) as any as S.Schema<PutIpResponse>;
+
+export interface PutIpFirewallRequest {
+  ip: string;
+  ipOnFirewall: string;
+  enabled?: boolean;
+}
+export const PutIpFirewallRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnFirewall: S.String.pipe(T.Label()),
+    enabled: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/ip/{ip}/firewall/{ipOnFirewall}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutIpFirewallRequest",
+}) as any as S.Schema<PutIpFirewallRequest>;
+
+export interface PutIpFirewallResponse {}
+export const PutIpFirewallResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpFirewallResponse",
+}) as any as S.Schema<PutIpFirewallResponse>;
+
+export interface PutIpGameRequest {
+  ip: string;
+  ipOnGame: string;
+  /** Firewall mode : in UDP, only allow traffic matching your rules (as well as established traffic). If not enabled, traffic to ports not defined in your rules will be permited. TCP traffic is unaffected by this. */
+  firewallModeEnabled?: boolean;
+}
+export const PutIpGameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnGame: S.String.pipe(T.Label()),
+    firewallModeEnabled: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/ip/{ip}/game/{ipOnGame}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutIpGameRequest",
+}) as any as S.Schema<PutIpGameRequest>;
+
+export interface PutIpGameResponse {}
+export const PutIpGameResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpGameResponse",
+}) as any as S.Schema<PutIpGameResponse>;
+
+export interface PutIpMitigationRequest {
+  ip: string;
+  ipOnMitigation: string;
+  /** Set on true if your ip is on permanent mitigation */
+  permanent?: boolean;
+}
+export const PutIpMitigationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipOnMitigation: S.String.pipe(T.Label()),
+    permanent: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/ip/{ip}/mitigation/{ipOnMitigation}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutIpMitigationRequest",
+}) as any as S.Schema<PutIpMitigationRequest>;
+
+export interface PutIpMitigationResponse {}
+export const PutIpMitigationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpMitigationResponse",
+}) as any as S.Schema<PutIpMitigationResponse>;
+
+export interface PutIpMitigationProfileRequest {
+  ip: string;
+  ipMitigationProfile: string;
+  /** Delay to wait before remove ip from auto mitigation after an attack */
+  autoMitigationTimeOut?:
+    | IpMitigationProfileAutoMitigationTimeOutEnum
+    | (number & {});
+}
+export const PutIpMitigationProfileRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipMitigationProfile: S.String.pipe(T.Label()),
+    autoMitigationTimeOut: S.optional(
+      IpMitigationProfileAutoMitigationTimeOutEnum,
+    ),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/ip/{ip}/mitigationProfiles/{ipMitigationProfile}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutIpMitigationProfileRequest",
+}) as any as S.Schema<PutIpMitigationProfileRequest>;
+
+export interface PutIpMitigationProfileResponse {}
+export const PutIpMitigationProfileResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpMitigationProfileResponse",
+}) as any as S.Schema<PutIpMitigationProfileResponse>;
+
+export interface PutIpRipeRequest {
+  ip: string;
+  description?: string | null;
+  netname?: string | null;
+}
+export const PutIpRipeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    description: S.optional(S.NullOr(S.String)),
+    netname: S.optional(S.NullOr(S.String)),
+  }).pipe(T.Http({ method: "PUT", uri: "/ip/{ip}/ripe", code: 200 })),
+).annotate({
+  identifier: "PutIpRipeRequest",
+}) as any as S.Schema<PutIpRipeRequest>;
+
+export interface PutIpRipeResponse {}
+export const PutIpRipeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpRipeResponse",
+}) as any as S.Schema<PutIpRipeResponse>;
+
+export interface PutIpServiceRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+  /** Custom description on your ip */
+  description?: string | null;
+}
+export const PutIpServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    description: S.optional(S.NullOr(S.String)),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/ip/service/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutIpServiceRequest",
+}) as any as S.Schema<PutIpServiceRequest>;
+
+export interface PutIpServiceResponse {}
+export const PutIpServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpServiceResponse",
+}) as any as S.Schema<PutIpServiceResponse>;
+
+export interface PutIpServiceServiceInfosRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutIpServiceServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/ip/service/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutIpServiceServiceInfosRequest",
+}) as any as S.Schema<PutIpServiceServiceInfosRequest>;
+
+export interface PutIpServiceServiceInfosResponse {}
+export const PutIpServiceServiceInfosResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutIpServiceServiceInfosResponse",
+}) as any as S.Schema<PutIpServiceServiceInfosResponse>;
+
+export interface TerminateIpServiceRequest {
+  /** The internal name of your IP services */
+  serviceName: string;
+}
+export const TerminateIpServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/service/{serviceName}/terminate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TerminateIpServiceRequest",
+}) as any as S.Schema<TerminateIpServiceRequest>;
+
+export type TerminateIpServiceResponse = string;
+export const TerminateIpServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateIpServiceResponse",
+}) as any as S.Schema<TerminateIpServiceResponse>;
+
+export interface UnblockIpAntihackRequest {
+  ip: string;
+  /** your IP */
+  ipBlocked: string;
+}
+export const UnblockIpAntihackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipBlocked: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/{ip}/antihack/{ipBlocked}/unblock",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UnblockIpAntihackRequest",
+}) as any as S.Schema<UnblockIpAntihackRequest>;
+
+export interface UnblockIpAntihackResponse {}
+export const UnblockIpAntihackResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UnblockIpAntihackResponse",
+}) as any as S.Schema<UnblockIpAntihackResponse>;
+
+export interface UnblockIpArpRequest {
+  ip: string;
+  /** your IP */
+  ipBlocked: string;
+}
+export const UnblockIpArpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipBlocked: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/{ip}/arp/{ipBlocked}/unblock",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UnblockIpArpRequest",
+}) as any as S.Schema<UnblockIpArpRequest>;
+
+export interface UnblockIpArpResponse {}
+export const UnblockIpArpResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UnblockIpArpResponse",
+}) as any as S.Schema<UnblockIpArpResponse>;
+
+export interface UnblockIpSpamRequest {
+  ip: string;
+  /** IP address which is sending spam */
+  ipSpamming: string;
+}
+export const UnblockIpSpamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.String.pipe(T.Label()),
+    ipSpamming: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/ip/{ip}/spam/{ipSpamming}/unblock",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UnblockIpSpamRequest",
+}) as any as S.Schema<UnblockIpSpamRequest>;
+
+export type ConfirmIpServiceTerminationError = OvhOpError;
+/** Confirm service termination */
+export const confirmIpServiceTermination: API.OperationMethod<
+  ConfirmIpServiceTerminationRequest,
+  ConfirmIpServiceTerminationResponse,
+  ConfirmIpServiceTerminationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfirmIpServiceTerminationRequest,
+  output: ConfirmIpServiceTerminationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpBringYourOwnIpAggregateError = OvhOpError;
+/** Aggregate a sliced BYOIP Additional IPs and it's neighbor(s) into a single bigger Additional IP parent */
+export const createIpBringYourOwnIpAggregate: API.OperationMethod<
+  CreateIpBringYourOwnIpAggregateRequest,
+  IpIpTask,
+  CreateIpBringYourOwnIpAggregateError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpBringYourOwnIpAggregateRequest,
+  output: IpIpTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpBringYourOwnIpSliceError = OvhOpError;
+/** Slice a BYOIP Additional IP into smaller Additional IPs */
+export const createIpBringYourOwnIpSlice: API.OperationMethod<
+  CreateIpBringYourOwnIpSliceRequest,
+  IpIpTask,
+  CreateIpBringYourOwnIpSliceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpBringYourOwnIpSliceRequest,
+  output: IpIpTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpChangeOrgError = OvhOpError;
+/** Change organisation of this IP */
+export const createIpChangeOrg: API.OperationMethod<
+  CreateIpChangeOrgRequest,
+  IpIpTask,
+  CreateIpChangeOrgError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpChangeOrgRequest,
+  output: IpIpTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpDelegationError = OvhOpError;
+/** Add target for reverse delegation on IPv6 subnet */
+export const createIpDelegation: API.OperationMethod<
+  CreateIpDelegationRequest,
+  IpReverseDelegation,
+  CreateIpDelegationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpDelegationRequest,
+  output: IpReverseDelegation,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpFirewallError = OvhOpError;
+/** AntiDDOS option. Add new IP on firewall */
+export const createIpFirewall: API.OperationMethod<
+  CreateIpFirewallRequest,
+  IpFirewallIp,
+  CreateIpFirewallError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpFirewallRequest,
+  output: IpFirewallIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpFirewallRuleError = OvhOpError;
+/** AntiDDOS option. Add new rule on your IP */
+export const createIpFirewallRule: API.OperationMethod<
+  CreateIpFirewallRuleRequest,
+  IpFirewallNetworkRule,
+  CreateIpFirewallRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpFirewallRuleRequest,
+  output: IpFirewallNetworkRule,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpGameRuleError = OvhOpError;
+/** Add new rule on your IP */
+export const createIpGameRule: API.OperationMethod<
+  CreateIpGameRuleRequest,
+  IpGameMitigationRule,
+  CreateIpGameRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpGameRuleRequest,
+  output: IpGameMitigationRule,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpMigrationTokenError = OvhOpError;
+/** Generate a migration token */
+export const createIpMigrationToken: API.OperationMethod<
+  CreateIpMigrationTokenRequest,
+  IpIpMigrationToken,
+  CreateIpMigrationTokenError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpMigrationTokenRequest,
+  output: IpIpMigrationToken,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpMitigationError = OvhOpError;
+/** AntiDDOS option. Add new IP on permanent mitigation */
+export const createIpMitigation: API.OperationMethod<
+  CreateIpMitigationRequest,
+  IpMitigationIp,
+  CreateIpMitigationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpMitigationRequest,
+  output: IpMitigationIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpMitigationProfileError = OvhOpError;
+/** Create new profile for one of your ip */
+export const createIpMitigationProfile: API.OperationMethod<
+  CreateIpMitigationProfileRequest,
+  IpMitigationProfile,
+  CreateIpMitigationProfileError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpMitigationProfileRequest,
+  output: IpMitigationProfile,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpParkError = OvhOpError;
+/** Park this IP */
+export const createIpPark: API.OperationMethod<
+  CreateIpParkRequest,
+  IpIpTask,
+  CreateIpParkError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpParkRequest,
+  output: IpIpTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpReverseError = OvhOpError;
+/** Add reverse on an ip */
+export const createIpReverse: API.OperationMethod<
+  CreateIpReverseRequest,
+  IpReverseIp,
+  CreateIpReverseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpReverseRequest,
+  output: IpReverseIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIpServiceChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createIpServiceChangeContact: API.OperationMethod<
+  CreateIpServiceChangeContactRequest,
+  CreateIpServiceChangeContactResponse,
+  CreateIpServiceChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIpServiceChangeContactRequest,
+  output: CreateIpServiceChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpDelegationError = OvhOpError;
+/** Delete a target for reverse delegation on IPv6 subnet */
+export const deleteIpDelegation: API.OperationMethod<
+  DeleteIpDelegationRequest,
+  DeleteIpDelegationResponse,
+  DeleteIpDelegationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpDelegationRequest,
+  output: DeleteIpDelegationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpFirewallError = OvhOpError;
+/** AntiDDOS option. Delete IP and rules from firewall */
+export const deleteIpFirewall: API.OperationMethod<
+  DeleteIpFirewallRequest,
+  DeleteIpFirewallResponse,
+  DeleteIpFirewallError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpFirewallRequest,
+  output: DeleteIpFirewallResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpFirewallRuleError = OvhOpError;
+/** AntiDDOS option. Delete rule */
+export const deleteIpFirewallRule: API.OperationMethod<
+  DeleteIpFirewallRuleRequest,
+  IpFirewallNetworkRule,
+  DeleteIpFirewallRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpFirewallRuleRequest,
+  output: IpFirewallNetworkRule,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpGameRuleError = OvhOpError;
+/** Delete rule */
+export const deleteIpGameRule: API.OperationMethod<
+  DeleteIpGameRuleRequest,
+  IpGameMitigationRule,
+  DeleteIpGameRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpGameRuleRequest,
+  output: IpGameMitigationRule,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpMitigationError = OvhOpError;
+/** AntiDDOS option. Delete IP from mitigation */
+export const deleteIpMitigation: API.OperationMethod<
+  DeleteIpMitigationRequest,
+  IpMitigationIp,
+  DeleteIpMitigationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpMitigationRequest,
+  output: IpMitigationIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpMitigationProfileError = OvhOpError;
+/** Delete mitigation profile */
+export const deleteIpMitigationProfile: API.OperationMethod<
+  DeleteIpMitigationProfileRequest,
+  DeleteIpMitigationProfileResponse,
+  DeleteIpMitigationProfileError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpMitigationProfileRequest,
+  output: DeleteIpMitigationProfileResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIpReverseError = OvhOpError;
+/** Delete a reverse on one IP */
+export const deleteIpReverse: API.OperationMethod<
+  DeleteIpReverseRequest,
+  DeleteIpReverseResponse,
+  DeleteIpReverseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIpReverseRequest,
+  output: DeleteIpReverseResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpError = OvhOpError;
+/** Get this object properties */
+export const getIp: API.OperationMethod<
+  GetIpRequest,
+  IpIpWithIAM,
+  GetIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpRequest,
+  output: IpIpWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpAntihackError = OvhOpError;
+/** Get this object properties */
+export const getIpAntihack: API.OperationMethod<
+  GetIpAntihackRequest,
+  IpBlockedIp,
+  GetIpAntihackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpAntihackRequest,
+  output: IpBlockedIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpArpError = OvhOpError;
+/** Get this object properties */
+export const getIpArp: API.OperationMethod<
+  GetIpArpRequest,
+  IpArpBlockedIp,
+  GetIpArpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpArpRequest,
+  output: IpArpBlockedIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpDelegationError = OvhOpError;
+/** Get this object properties */
+export const getIpDelegation: API.OperationMethod<
+  GetIpDelegationRequest,
+  IpReverseDelegation,
+  GetIpDelegationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpDelegationRequest,
+  output: IpReverseDelegation,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpFirewallError = OvhOpError;
+/** Get this object properties */
+export const getIpFirewall: API.OperationMethod<
+  GetIpFirewallRequest,
+  IpFirewallIp,
+  GetIpFirewallError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpFirewallRequest,
+  output: IpFirewallIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpFirewallRuleError = OvhOpError;
+/** Get this object properties */
+export const getIpFirewallRule: API.OperationMethod<
+  GetIpFirewallRuleRequest,
+  IpFirewallNetworkRule,
+  GetIpFirewallRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpFirewallRuleRequest,
+  output: IpFirewallNetworkRule,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpGameError = OvhOpError;
+/** Get this object properties */
+export const getIpGame: API.OperationMethod<
+  GetIpGameRequest,
+  IpGameMitigation,
+  GetIpGameError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpGameRequest,
+  output: IpGameMitigation,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpGameRuleError = OvhOpError;
+/** Get this object properties */
+export const getIpGameRule: API.OperationMethod<
+  GetIpGameRuleRequest,
+  IpGameMitigationRule,
+  GetIpGameRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpGameRuleRequest,
+  output: IpGameMitigationRule,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpMigrationTokenError = OvhOpError;
+/** Get this object properties */
+export const getIpMigrationToken: API.OperationMethod<
+  GetIpMigrationTokenRequest,
+  IpIpMigrationToken,
+  GetIpMigrationTokenError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpMigrationTokenRequest,
+  output: IpIpMigrationToken,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpMitigationError = OvhOpError;
+/** Get this object properties */
+export const getIpMitigation: API.OperationMethod<
+  GetIpMitigationRequest,
+  IpMitigationIp,
+  GetIpMitigationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpMitigationRequest,
+  output: IpMitigationIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpMitigationProfileError = OvhOpError;
+/** Get this object properties */
+export const getIpMitigationProfile: API.OperationMethod<
+  GetIpMitigationProfileRequest,
+  IpMitigationProfile,
+  GetIpMitigationProfileError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpMitigationProfileRequest,
+  output: IpMitigationProfile,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpPhishingError = OvhOpError;
+/** Get this object properties */
+export const getIpPhishing: API.OperationMethod<
+  GetIpPhishingRequest,
+  IpAntiphishing,
+  GetIpPhishingError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpPhishingRequest,
+  output: IpAntiphishing,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpReverseError = OvhOpError;
+/** Get this object properties */
+export const getIpReverse: API.OperationMethod<
+  GetIpReverseRequest,
+  IpReverseIp,
+  GetIpReverseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpReverseRequest,
+  output: IpReverseIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpRipeError = OvhOpError;
+/** Get this object properties */
+export const getIpRipe: API.OperationMethod<
+  GetIpRipeRequest,
+  IpRipeInfos,
+  GetIpRipeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpRipeRequest,
+  output: IpRipeInfos,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpServiceError = OvhOpError;
+/** Get this object properties */
+export const getIpService: API.OperationMethod<
+  GetIpServiceRequest,
+  IpServiceIpWithIAM,
+  GetIpServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpServiceRequest,
+  output: IpServiceIpWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpServiceServiceInfosError = OvhOpError;
+/** Get service information */
+export const getIpServiceServiceInfos: API.OperationMethod<
+  GetIpServiceServiceInfosRequest,
+  ServicesService,
+  GetIpServiceServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpServiceServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpSpamError = OvhOpError;
+/** Get this object properties */
+export const getIpSpam: API.OperationMethod<
+  GetIpSpamRequest,
+  IpSpamIp,
+  GetIpSpamError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpSpamRequest,
+  output: IpSpamIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIpTaskError = OvhOpError;
+/** Get this object properties */
+export const getIpTask: API.OperationMethod<
+  GetIpTaskRequest,
+  IpIpTask,
+  GetIpTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIpTaskRequest,
+  output: IpIpTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpError = OvhOpError;
+/** Your OVH IPs */
+export const listIp: API.OperationMethod<
+  ListIpRequest,
+  ListIpResponse,
+  ListIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpRequest,
+  output: ListIpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpAntihackError = OvhOpError;
+/** Anti-Hack blocked IP */
+export const listIpAntihack: API.OperationMethod<
+  ListIpAntihackRequest,
+  ListIpAntihackResponse,
+  ListIpAntihackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpAntihackRequest,
+  output: ListIpAntihackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpArpError = OvhOpError;
+/** ARP blocked IP */
+export const listIpArp: API.OperationMethod<
+  ListIpArpRequest,
+  ListIpArpResponse,
+  ListIpArpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpArpRequest,
+  output: ListIpArpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpBringYourOwnIpAggregateError = OvhOpError;
+/** Get available aggregation configurations for this BYOIP Additional IP and it's neighbor(s) */
+export const listIpBringYourOwnIpAggregate: API.OperationMethod<
+  ListIpBringYourOwnIpAggregateRequest,
+  ListIpBringYourOwnIpAggregateResponse,
+  ListIpBringYourOwnIpAggregateError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpBringYourOwnIpAggregateRequest,
+  output: ListIpBringYourOwnIpAggregateResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpBringYourOwnIpSliceError = OvhOpError;
+/** Get available slicing configurations for this BYOIP Additional IP */
+export const listIpBringYourOwnIpSlice: API.OperationMethod<
+  ListIpBringYourOwnIpSliceRequest,
+  ListIpBringYourOwnIpSliceResponse,
+  ListIpBringYourOwnIpSliceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpBringYourOwnIpSliceRequest,
+  output: ListIpBringYourOwnIpSliceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpCampusError = OvhOpError;
+/** Get IP campuses */
+export const listIpCampus: API.OperationMethod<
+  ListIpCampusRequest,
+  ListIpCampusResponse,
+  ListIpCampusError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpCampusRequest,
+  output: ListIpCampusResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpDelegationError = OvhOpError;
+/** Reverse delegation on IPv6 subnet */
+export const listIpDelegation: API.OperationMethod<
+  ListIpDelegationRequest,
+  ListIpDelegationResponse,
+  ListIpDelegationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpDelegationRequest,
+  output: ListIpDelegationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpFirewallError = OvhOpError;
+/** Ip under firewall */
+export const listIpFirewall: API.OperationMethod<
+  ListIpFirewallRequest,
+  ListIpFirewallResponse,
+  ListIpFirewallError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpFirewallRequest,
+  output: ListIpFirewallResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpFirewallRuleError = OvhOpError;
+/** Rules for this IP */
+export const listIpFirewallRule: API.OperationMethod<
+  ListIpFirewallRuleRequest,
+  ListIpFirewallRuleResponse,
+  ListIpFirewallRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpFirewallRuleRequest,
+  output: ListIpFirewallRuleResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpGameError = OvhOpError;
+/** Ip under game anti-ddos */
+export const listIpGame: API.OperationMethod<
+  ListIpGameRequest,
+  ListIpGameResponse,
+  ListIpGameError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpGameRequest,
+  output: ListIpGameResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpGameRuleError = OvhOpError;
+/** IDs of rules configured for this IP */
+export const listIpGameRule: API.OperationMethod<
+  ListIpGameRuleRequest,
+  ListIpGameRuleResponse,
+  ListIpGameRuleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpGameRuleRequest,
+  output: ListIpGameRuleResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseCloudLinuxError = OvhOpError;
+/** Cloud Linux licenses associated to this IP */
+export const listIpLicenseCloudLinux: API.OperationMethod<
+  ListIpLicenseCloudLinuxRequest,
+  ListIpLicenseCloudLinuxResponse,
+  ListIpLicenseCloudLinuxError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseCloudLinuxRequest,
+  output: ListIpLicenseCloudLinuxResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseCpanelError = OvhOpError;
+/** Cpanel licenses associated to this IP */
+export const listIpLicenseCpanel: API.OperationMethod<
+  ListIpLicenseCpanelRequest,
+  ListIpLicenseCpanelResponse,
+  ListIpLicenseCpanelError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseCpanelRequest,
+  output: ListIpLicenseCpanelResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseDirectadminError = OvhOpError;
+/** DirectAdmin licenses associated to this IP */
+export const listIpLicenseDirectadmin: API.OperationMethod<
+  ListIpLicenseDirectadminRequest,
+  ListIpLicenseDirectadminResponse,
+  ListIpLicenseDirectadminError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseDirectadminRequest,
+  output: ListIpLicenseDirectadminResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicensePleskError = OvhOpError;
+/** Plesk licenses associated to this IP */
+export const listIpLicensePlesk: API.OperationMethod<
+  ListIpLicensePleskRequest,
+  ListIpLicensePleskResponse,
+  ListIpLicensePleskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicensePleskRequest,
+  output: ListIpLicensePleskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseSqlserverError = OvhOpError;
+/** SQL Server licenses associated to this IP */
+export const listIpLicenseSqlserver: API.OperationMethod<
+  ListIpLicenseSqlserverRequest,
+  ListIpLicenseSqlserverResponse,
+  ListIpLicenseSqlserverError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseSqlserverRequest,
+  output: ListIpLicenseSqlserverResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseVirtuozzoError = OvhOpError;
+/** Virtuozzo licenses associated to this IP */
+export const listIpLicenseVirtuozzo: API.OperationMethod<
+  ListIpLicenseVirtuozzoRequest,
+  ListIpLicenseVirtuozzoResponse,
+  ListIpLicenseVirtuozzoError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseVirtuozzoRequest,
+  output: ListIpLicenseVirtuozzoResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseWindowsError = OvhOpError;
+/** Windows licenses associated to this IP */
+export const listIpLicenseWindows: API.OperationMethod<
+  ListIpLicenseWindowsRequest,
+  ListIpLicenseWindowsResponse,
+  ListIpLicenseWindowsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseWindowsRequest,
+  output: ListIpLicenseWindowsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpLicenseWorklightError = OvhOpError;
+/** WorkLight licenses associated to this IP */
+export const listIpLicenseWorklight: API.OperationMethod<
+  ListIpLicenseWorklightRequest,
+  ListIpLicenseWorklightResponse,
+  ListIpLicenseWorklightError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpLicenseWorklightRequest,
+  output: ListIpLicenseWorklightResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpMitigationError = OvhOpError;
+/** Ip under mitigation */
+export const listIpMitigation: API.OperationMethod<
+  ListIpMitigationRequest,
+  ListIpMitigationResponse,
+  ListIpMitigationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpMitigationRequest,
+  output: ListIpMitigationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpMitigationProfilesError = OvhOpError;
+/** Manage mitigation profile on your IPs */
+export const listIpMitigationProfiles: API.OperationMethod<
+  ListIpMitigationProfilesRequest,
+  ListIpMitigationProfilesResponse,
+  ListIpMitigationProfilesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpMitigationProfilesRequest,
+  output: ListIpMitigationProfilesResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpMoveError = OvhOpError;
+/** List services available as a destination */
+export const listIpMove: API.OperationMethod<
+  ListIpMoveRequest,
+  IpDestinations,
+  ListIpMoveError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpMoveRequest,
+  output: IpDestinations,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpPhishingError = OvhOpError;
+/** Ip under anti-phishing */
+export const listIpPhishing: API.OperationMethod<
+  ListIpPhishingRequest,
+  ListIpPhishingResponse,
+  ListIpPhishingError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpPhishingRequest,
+  output: ListIpPhishingResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpReverseError = OvhOpError;
+/** Reverse on your ip */
+export const listIpReverse: API.OperationMethod<
+  ListIpReverseRequest,
+  ListIpReverseResponse,
+  ListIpReverseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpReverseRequest,
+  output: ListIpReverseResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpServiceError = OvhOpError;
+/** Your ip services */
+export const listIpService: API.OperationMethod<
+  ListIpServiceRequest,
+  ListIpServiceResponse,
+  ListIpServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpServiceRequest,
+  output: ListIpServiceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpSpamError = OvhOpError;
+/** Ip spamming */
+export const listIpSpam: API.OperationMethod<
+  ListIpSpamRequest,
+  ListIpSpamResponse,
+  ListIpSpamError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpSpamRequest,
+  output: ListIpSpamResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpSpamStatsError = OvhOpError;
+/** Get statistics about the email traffic */
+export const listIpSpamStats: API.OperationMethod<
+  ListIpSpamStatsRequest,
+  ListIpSpamStatsResponse,
+  ListIpSpamStatsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpSpamStatsRequest,
+  output: ListIpSpamStatsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIpTaskError = OvhOpError;
+/** IP tasks */
+export const listIpTask: API.OperationMethod<
+  ListIpTaskRequest,
+  ListIpTaskResponse,
+  ListIpTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIpTaskRequest,
+  output: ListIpTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveIpError = OvhOpError;
+/** Move this IP to another service */
+export const moveIp: API.OperationMethod<
+  MoveIpRequest,
+  IpIpTask,
+  MoveIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveIpRequest,
+  output: IpIpTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpError = OvhOpError;
+/** Alter this object properties */
+export const putIp: API.OperationMethod<
+  PutIpRequest,
+  PutIpResponse,
+  PutIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpRequest,
+  output: PutIpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpFirewallError = OvhOpError;
+/** Alter this object properties */
+export const putIpFirewall: API.OperationMethod<
+  PutIpFirewallRequest,
+  PutIpFirewallResponse,
+  PutIpFirewallError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpFirewallRequest,
+  output: PutIpFirewallResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpGameError = OvhOpError;
+/** Alter this object properties */
+export const putIpGame: API.OperationMethod<
+  PutIpGameRequest,
+  PutIpGameResponse,
+  PutIpGameError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpGameRequest,
+  output: PutIpGameResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpMitigationError = OvhOpError;
+/** Alter this object properties */
+export const putIpMitigation: API.OperationMethod<
+  PutIpMitigationRequest,
+  PutIpMitigationResponse,
+  PutIpMitigationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpMitigationRequest,
+  output: PutIpMitigationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpMitigationProfileError = OvhOpError;
+/** Alter this object properties */
+export const putIpMitigationProfile: API.OperationMethod<
+  PutIpMitigationProfileRequest,
+  PutIpMitigationProfileResponse,
+  PutIpMitigationProfileError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpMitigationProfileRequest,
+  output: PutIpMitigationProfileResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpRipeError = OvhOpError;
+/** Alter this object properties */
+export const putIpRipe: API.OperationMethod<
+  PutIpRipeRequest,
+  PutIpRipeResponse,
+  PutIpRipeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpRipeRequest,
+  output: PutIpRipeResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpServiceError = OvhOpError;
+/** Alter this object properties */
+export const putIpService: API.OperationMethod<
+  PutIpServiceRequest,
+  PutIpServiceResponse,
+  PutIpServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpServiceRequest,
+  output: PutIpServiceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutIpServiceServiceInfosError = OvhOpError;
+/** Update service information */
+export const putIpServiceServiceInfos: API.OperationMethod<
+  PutIpServiceServiceInfosRequest,
+  PutIpServiceServiceInfosResponse,
+  PutIpServiceServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutIpServiceServiceInfosRequest,
+  output: PutIpServiceServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateIpServiceError = OvhOpError;
+/** Ask for the termination of your service Ask for the termination of your service. Admin contact of this service will receive a termination token by email in order to confirm its termination with /confirmTermination endpoint. */
+export const terminateIpService: API.OperationMethod<
+  TerminateIpServiceRequest,
+  TerminateIpServiceResponse,
+  TerminateIpServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateIpServiceRequest,
+  output: TerminateIpServiceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UnblockIpAntihackError = OvhOpError;
+/** Unblock this IP */
+export const unblockIpAntihack: API.OperationMethod<
+  UnblockIpAntihackRequest,
+  UnblockIpAntihackResponse,
+  UnblockIpAntihackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UnblockIpAntihackRequest,
+  output: UnblockIpAntihackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UnblockIpArpError = OvhOpError;
+/** Unblock this IP */
+export const unblockIpArp: API.OperationMethod<
+  UnblockIpArpRequest,
+  UnblockIpArpResponse,
+  UnblockIpArpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UnblockIpArpRequest,
+  output: UnblockIpArpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UnblockIpSpamError = OvhOpError;
+/** Release the ip from anti-spam system */
+export const unblockIpSpam: API.OperationMethod<
+  UnblockIpSpamRequest,
+  IpSpamIp,
+  UnblockIpSpamError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UnblockIpSpamRequest,
+  output: IpSpamIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));